ALPHA: wire is a tool to deploy nixos systems
wire.althaea.zone/
althaea.zone
Compare changes
Choose any two refs to compare.
+2
-23
.github/actions/setup-nix/action.yml
+2
-23
.github/actions/setup-nix/action.yml
···
3
3
description: |
4
4
Sets up the Nix environment for wire, removing unnecessary bloat and installing Nix along with proper
5
5
substituters being set
6
-
inputs:
7
-
withQEMU:
8
-
description: Enable QEMU
9
-
default: false
10
6
runs:
11
7
using: "composite"
12
8
steps:
13
-
- uses: wimpysworld/nothing-but-nix@main
14
-
with:
15
-
hatchet-protocol: "carve"
16
9
- name: Generate nix.conf
17
10
shell: bash
18
11
id: config
···
21
14
echo 'config<<EOF'
22
15
echo "system-features = nixos-test benchmark big-parallel kvm"
23
16
24
-
if [ "${{ inputs.withQEMU }}" = "true" ]; then
25
-
echo "extra-platforms = aarch64-linux i686-linux"
26
-
fi
27
-
28
17
echo "substituters = https://cache.nixos.org?priority=1 https://cache.althaea.zone?priority=2 https://cache.garnix.io?priority=3"
29
18
echo "trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= cache.garnix.io:CTFPyKSLcx5RMJKfLo5EEPUObbA78b0YQ2DTCJXqr9g= cache.althaea.zone:BelRpa863X9q3Y+AOnl5SM7QFzre3qb+5I7g2s/mqHI="
30
19
31
20
echo EOF
32
21
} >> "$GITHUB_OUTPUT"
33
-
- uses: cachix/install-nix-action@v31
22
+
- uses: cachix/install-nix-action@4e002c8ec80594ecd40e759629461e26c8abed15
34
23
with:
35
24
nix_path: nixpkgs=channel:nixos-unstable
36
25
extra_nix_config: ${{ steps.config.outputs.config }}
37
26
- name: Sanity check nix.conf
38
-
if: ${{ inputs.withQEMU == 'true' && runner.debug == '1' }}
27
+
if: ${{ runner.debug == '1' }}
39
28
shell: bash
40
29
run: cat /etc/nix/nix.conf
41
-
- name: Register binfmt
42
-
if: ${{ inputs.withQEMU == 'true' }}
43
-
shell: bash
44
-
run: |
45
-
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
46
-
- name: Sanity check binfmt
47
-
if: ${{ inputs.withQEMU == 'true' && runner.debug == '1' }}
48
-
shell: bash
49
-
run: |
50
-
cat /proc/sys/fs/binfmt_misc/qemu-aarch64
+24
-7
.github/workflows/autofix.yml
+24
-7
.github/workflows/autofix.yml
···
3
3
on:
4
4
pull_request:
5
5
push:
6
-
branches: ["trunk"]
7
6
8
7
permissions:
9
8
contents: read
···
14
13
outputs:
15
14
docs-pnpm: ${{ steps.filter.outputs.docs-pnpm }}
16
15
steps:
17
-
- uses: actions/checkout@v6
18
-
- uses: dorny/paths-filter@v3
16
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
17
+
with:
18
+
persist-credentials: false
19
+
- uses: dorny/paths-filter@668c092af3649c4b664c54e4b704aa46782f6f7c
19
20
id: filter
20
21
with:
21
22
filters: |
22
23
docs-pnpm:
23
24
- 'doc/pnpm-lock.yaml'
24
25
autofix:
25
-
runs-on: ubuntu-latest
26
+
runs-on: blacksmith-2vcpu-ubuntu-2404
26
27
needs: check-changes
28
+
env:
29
+
UV_CACHE_DIR: /tmp/.uv-cache
27
30
steps:
28
-
- uses: actions/checkout@v6
31
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
32
+
with:
33
+
persist-credentials: false
29
34
- uses: ./.github/actions/setup-nix
30
35
- name: Cache Cargo
31
-
uses: actions/cache@v4
36
+
uses: actions/cache@v5
32
37
with:
33
38
path: |
34
39
~/.cargo/bin/
···
36
41
~/.cargo/registry/cache/
37
42
~/.cargo/git/db/
38
43
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
44
+
- name: Cache uv
45
+
uses: actions/cache@v5
46
+
with:
47
+
path: /tmp/.uv-cache
48
+
key: uv-${{ runner.os }}-${{ hashFiles('**/uv.lock') }}
49
+
restore-keys: |
50
+
uv-${{ runner.os }}-${{ hashFiles('**/uv.lock') }}
51
+
uv-${{ runner.os }}
39
52
- name: setup sqlx
40
-
run: nix develop -L -v -c sqlx database setup --source ./wire/lib/src/cache/migrations/
53
+
run: nix develop -L -v -c sqlx database setup --source ./crates/core/src/cache/migrations/
54
+
- name: autofix sqlx
55
+
run: nix develop -L -v -c cargo sqlx prepare --workspace
41
56
- name: clippy --fix
42
57
run: nix develop -L -v -c cargo clippy --fix
43
58
- name: pre-commit run
···
46
61
- name: Upgrade Hash
47
62
if: ${{ needs.check-changes.outputs.docs-pnpm == 'true' }}
48
63
run: bash ./doc/upgrade.sh
64
+
- name: Minimise uv cache
65
+
run: nix develop -L -v -c uv cache prune --ci
49
66
- uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27
+10
-4
.github/workflows/follow-nixpkgs.yml
+10
-4
.github/workflows/follow-nixpkgs.yml
···
8
8
pre-job:
9
9
continue-on-error: true
10
10
runs-on: ubuntu-latest
11
+
permissions: {}
11
12
outputs:
12
13
number: ${{ steps.skip_check.outputs.number }}
13
14
steps:
14
-
- uses: actions/checkout@v6
15
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
16
+
with:
17
+
persist-credentials: false
15
18
- id: skip_check
16
19
run: |
17
20
echo "number=$(gh pr list --label flake-lock-update --state open --json id | jq 'length')" >> "$GITHUB_OUTPUT"
···
19
22
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
20
23
update:
21
24
runs-on: ubuntu-latest
25
+
permissions: {}
22
26
needs: pre-job
23
27
if: needs.pre-job.outputs.number == '0'
24
28
steps:
25
-
- uses: actions/checkout@v6
29
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
26
30
with:
27
31
ssh-key: ${{ secrets.FOLLOW_NIXPKGS_PRIVATE_KEY }}
28
32
ref: main
33
+
persist-credentials: false
29
34
- uses: ./.github/actions/setup-nix
30
35
- run: |
31
36
git config user.name 'github-actions[bot]'
···
36
41
run: echo "date=$(date +'%Y-%m-%d')" >> "$GITHUB_OUTPUT"
37
42
- name: Create Pull Request
38
43
id: cpr
39
-
uses: peter-evans/create-pull-request@v7
44
+
uses: peter-evans/create-pull-request@0979079bc20c05bbbb590a56c21c4e2b1d1f1bbe
40
45
with:
41
46
title: Update flake.lock ${{ steps.date.outputs.date }}
42
47
labels: flake-lock-update
43
48
branch: ci/flake-update
44
49
- name: Enable automerge
45
50
if: steps.cpr.outputs.pull-request-number
46
-
run: gh pr merge --squash --auto "${{ steps.cpr.outputs.pull-request-number }}"
51
+
run: gh pr merge --squash --auto "${STEPS_CPR_OUTPUTS_PULL_REQUEST_NUMBER}"
47
52
env:
48
53
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
54
+
STEPS_CPR_OUTPUTS_PULL_REQUEST_NUMBER: ${{ steps.cpr.outputs.pull-request-number }}
+1
-1
.github/workflows/labeler.yml
+1
-1
.github/workflows/labeler.yml
+7
-3
.github/workflows/pages.yml
+7
-3
.github/workflows/pages.yml
···
10
10
pre-job:
11
11
continue-on-error: true
12
12
runs-on: ubuntu-latest
13
+
permissions: {}
13
14
outputs:
14
15
should_skip: ${{ steps.skip_check.outputs.should_skip }}
15
16
steps:
16
17
- id: skip_check
17
-
uses: fkirc/skip-duplicate-actions@v5
18
+
uses: fkirc/skip-duplicate-actions@04a1aebece824b56e6ad6a401d015479cd1c50b3
18
19
deploy:
19
20
runs-on: ubuntu-latest
21
+
permissions: {}
20
22
environment:
21
23
name: production
22
24
url: https://wire.althaea.zone/
23
25
if: github.actor != 'dependabot[bot]' && needs.pre-job.outputs.should_skip != 'true'
24
26
steps:
25
-
- uses: actions/checkout@v6
27
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
28
+
with:
29
+
persist-credentials: false
26
30
- uses: ./.github/actions/setup-nix
27
31
- run: nix build .#docs
28
32
if: github.ref == 'refs/heads/stable'
···
30
34
if: github.ref != 'refs/heads/stable'
31
35
- name: Deploy to Cloudflare Pages
32
36
id: deployment
33
-
uses: cloudflare/wrangler-action@v3
37
+
uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65
34
38
with:
35
39
apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
36
40
accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+17
-6
.github/workflows/pr-preview.yml
+17
-6
.github/workflows/pr-preview.yml
···
7
7
runs-on: ubuntu-latest
8
8
outputs:
9
9
number: ${{ steps.find-pr.outputs.number }}
10
+
permissions: {}
10
11
if: ${{ github.actor != 'dependabot[bot]' }}
11
12
steps:
12
-
- uses: jwalton/gh-find-current-pr@master
13
+
- uses: jwalton/gh-find-current-pr@89ee5799558265a1e0e31fab792ebb4ee91c016b
13
14
id: find-pr
14
15
with:
15
16
state: all
16
17
base-ref:
17
18
runs-on: ubuntu-latest
19
+
permissions: {}
18
20
needs: get-pr
19
21
outputs:
20
22
base-ref: ${{ steps.base-ref.outputs.base-ref }}
···
24
26
- name: Locate Base Ref
25
27
id: base-ref
26
28
run: |
27
-
echo "base-ref=$(gh api /repos/${{ github.repository }}/pulls/${{ needs.get-pr.outputs.number }} | jq -r '.base.ref')" >> "$GITHUB_OUTPUT"
29
+
echo "base-ref=$(gh api /repos/${{ github.repository }}/pulls/${NEEDS_GET_PR_OUTPUTS_NUMBER} | jq -r '.base.ref')" >> "$GITHUB_OUTPUT"
28
30
env:
29
31
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
32
+
NEEDS_GET_PR_OUTPUTS_NUMBER: ${{ needs.get-pr.outputs.number }}
30
33
eval-base:
31
34
runs-on: ubuntu-latest
35
+
permissions: {}
32
36
needs: base-ref
33
37
outputs:
34
38
drv: ${{ steps.drv.outputs.drv }}
35
39
steps:
36
-
- uses: actions/checkout@v6
40
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
37
41
with:
38
42
ref: ${{ needs.base-ref.outputs.base-ref }}
43
+
persist-credentials: false
39
44
- uses: ./.github/actions/setup-nix
40
45
- id: drv
41
46
run: echo "drv=$(nix eval .#docs --json)" >> "$GITHUB_OUTPUT"
42
47
eval-head:
43
48
runs-on: ubuntu-latest
49
+
permissions: {}
44
50
needs: get-pr
45
51
outputs:
46
52
drv: ${{ steps.drv.outputs.drv }}
47
53
if: ${{ needs.get-pr.outputs.number != '' }}
48
54
steps:
49
-
- uses: actions/checkout@v6
55
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
56
+
with:
57
+
persist-credentials: false
50
58
- uses: ./.github/actions/setup-nix
51
59
- id: drv
52
60
run: echo "drv=$(nix eval .#docs --json)" >> "$GITHUB_OUTPUT"
53
61
deploy:
54
62
runs-on: ubuntu-latest
63
+
permissions: {}
55
64
needs:
56
65
- eval-head
57
66
- eval-base
···
62
71
# skip if nothing changed in the docs package
63
72
if: needs.eval-head.outputs.drv != needs.eval-base.outputs.drv
64
73
steps:
65
-
- uses: actions/checkout@v6
74
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
75
+
with:
76
+
persist-credentials: false
66
77
- uses: ./.github/actions/setup-nix
67
78
- run: nix build .#docs
68
79
- name: Deploy to Cloudflare Pages
69
80
id: deployment
70
-
uses: cloudflare/wrangler-action@v3
81
+
uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65
71
82
with:
72
83
apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
73
84
accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+5
-2
.github/workflows/test.yml
+5
-2
.github/workflows/test.yml
···
7
7
pre-job:
8
8
continue-on-error: true
9
9
runs-on: ubuntu-latest
10
+
permissions: {}
10
11
outputs:
11
12
should_skip: ${{ steps.skip_check.outputs.should_skip }}
12
13
steps:
13
14
- id: skip_check
14
-
uses: fkirc/skip-duplicate-actions@v5
15
+
uses: fkirc/skip-duplicate-actions@04a1aebece824b56e6ad6a401d015479cd1c50b3
15
16
with:
16
17
concurrent_skipping: "same_content_newer"
17
18
cancel_others: "true"
···
22
23
contents: read
23
24
if: needs.pre-job.outputs.should_skip != 'true'
24
25
steps:
25
-
- uses: actions/checkout@v6
26
+
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
27
+
with:
28
+
persist-credentials: false
26
29
- uses: ./.github/actions/setup-nix
27
30
- name: Build Tests
28
31
run: nix build .#cargo-tests -L -vv
+4
.gitignore
+4
.gitignore
-20
.sqlx/query-5513de9a13d5ef4f8d667159c4f7a1e487ae03e2ec7b03b754e5d08076b0d78d.json
-20
.sqlx/query-5513de9a13d5ef4f8d667159c4f7a1e487ae03e2ec7b03b754e5d08076b0d78d.json
···
1
-
{
2
-
"db_name": "SQLite",
3
-
"query": "\n select inspection_blobs.json_value from inspection_blobs\n join inspection_cache\n on inspection_cache.blob_id = inspection_blobs.id\n where inspection_cache.store_path = $1\n and inspection_cache.hash = $2\n and inspection_blobs.schema_version = $3\n limit 1\n ",
4
-
"describe": {
5
-
"columns": [
6
-
{
7
-
"name": "json_value",
8
-
"ordinal": 0,
9
-
"type_info": "Blob"
10
-
}
11
-
],
12
-
"parameters": {
13
-
"Right": 3
14
-
},
15
-
"nullable": [
16
-
false
17
-
]
18
-
},
19
-
"hash": "5513de9a13d5ef4f8d667159c4f7a1e487ae03e2ec7b03b754e5d08076b0d78d"
20
-
}
+26
.sqlx/query-810100e8d8c033a0d0b77fe8e90a212cd2c1e8718ee347fba3076bcd10f19198.json
+26
.sqlx/query-810100e8d8c033a0d0b77fe8e90a212cd2c1e8718ee347fba3076bcd10f19198.json
···
1
+
{
2
+
"db_name": "SQLite",
3
+
"query": "\n select\n inspection_blobs.json_value,\n inspection_cache.store_path\n from\n inspection_blobs\n join inspection_cache on inspection_cache.blob_id = inspection_blobs.id\n where\n inspection_cache.store_path = $1\n and inspection_cache.hash = $2\n and inspection_blobs.schema_version = $3\n limit\n 1\n ",
4
+
"describe": {
5
+
"columns": [
6
+
{
7
+
"name": "json_value",
8
+
"ordinal": 0,
9
+
"type_info": "Blob"
10
+
},
11
+
{
12
+
"name": "store_path",
13
+
"ordinal": 1,
14
+
"type_info": "Text"
15
+
}
16
+
],
17
+
"parameters": {
18
+
"Right": 3
19
+
},
20
+
"nullable": [
21
+
false,
22
+
false
23
+
]
24
+
},
25
+
"hash": "810100e8d8c033a0d0b77fe8e90a212cd2c1e8718ee347fba3076bcd10f19198"
26
+
}
+75
-36
CHANGELOG.md
+75
-36
CHANGELOG.md
···
7
7
8
8
## [Unreleased] - yyyy-mm-dd
9
9
10
+
### Fixed
11
+
12
+
- Fix a bug where key permissions where being printed in decimal format instead
13
+
of octal.
14
+
15
+
## [v1.1.1] - 2025-01-05
16
+
17
+
### Fixed
18
+
19
+
- Fix a bug where wire was attempting to SSH to the local machine when `buildOnTarget` &
20
+
`allowLocalDeployment` where true.
21
+
22
+
## [v1.1.0] - 2025-12-31
23
+
24
+
### Added
25
+
26
+
- Add a `--substitute-on-destination` argument.
27
+
- Add the `meta.nodeSpecialArgs` meta option.
28
+
- Add `wire build`, a new command to build nodes offline.
29
+
It is distinct from `wire apply build`, as it will not ping
30
+
or push the result, making it useful for CI.
31
+
32
+
### Changed
33
+
34
+
- Build store paths will be output to stdout
35
+
36
+
### Fixed
37
+
38
+
- Fix invalidated caches not actually returning `None`.
39
+
40
+
## [v1.0.0] - 2025-12-17
41
+
42
+
### Added
43
+
44
+
- SIGINT signal handling.
45
+
46
+
### Changed
47
+
48
+
- Invalidate caches that reference garbage collected paths.
49
+
50
+
### Fixed
51
+
52
+
- Fix key filtering logic.
53
+
10
54
## [v1.0.0-beta.0] - 2025-12-02
11
55
12
56
### Added
13
57
14
-
- `meta.nodeNixpkgs` was implemented.
15
-
- Caching of hive evaluation for flakes.
58
+
- Implement `meta.nodeNixpkgs`.
59
+
- Add caching of hive evaluation for flakes.
16
60
17
61
### Changed
18
62
19
-
- Tests are now ran on 25.11.
63
+
- Run tests against 25.11.
20
64
21
65
## [v1.0.0-alpha.1] - 2025-11-24
22
66
23
67
### Added
24
68
25
-
- `--handle-unreachable` arg was added. You can use `--handle-unreachable ignore` to
69
+
- Add `--handle-unreachable`. You can use `--handle-unreachable ignore` to
26
70
ignore unreachable nodes in the status of the deployment.
27
-
- A basic progress bar
71
+
- Add a basic progress bar.
28
72
29
73
### Changed
30
74
31
-
- Reverted "Wire will now attempt to use SSH ControlMaster by default."
32
-
- `show` subcommand looks nicer now.
33
-
- `build` step will always build remotely when the node is going to be applied
34
-
locally.
75
+
- Revert "Wire will now attempt to use SSH ControlMaster by default.".
76
+
- Change the `show` subcommand to look nicer now.
77
+
- Change the `build` step to always build remotely when the node is
78
+
going to be applied locally.
35
79
36
80
## [v1.0.0-alpha.0] - 2025-10-22
37
81
38
82
### Added
39
83
40
-
- `--ssh-accept-host` was added.
41
-
- `--on -` will now read additional apply targets from stdin.
42
-
- `{key.name}-key.{path,service}` systemd units where added.
43
-
- `--path` now supports flakerefs (`github:foo/bar`, `git+file:///...`,
44
-
`https://.../main.tar.gz`, etc).
45
-
- `--flake` is now an alias for `--path`.
46
-
- Wire will now attempt to use SSH ControlMaster by default.
84
+
- Add `--ssh-accept-host` argument.
85
+
- Add `--on -` syntax to the `--on` argument.
86
+
Passing `-` will now read additional apply targets from stdin.
87
+
- Add `{key.name}-key.{path,service}` systemd units.
88
+
- Added `--flake` argument as an alias for `--path`.
47
89
- A terminal bell will be output if a sudo / ssh prompt is ever printed.
90
+
- Added a real tutorial, and separated many how-to guides.
91
+
The tutorial leads the user through creating and deploying a wire Hive.
92
+
- Add `config.nixpkgs.flake.source` by default if `meta.nixpkgs` ends
93
+
with `-source` at priority 1000 (default).
48
94
49
95
### Fixed
50
96
51
-
- Fix bug where `--non-interactive` was inversed
52
-
- `./result` links where being created. they will not be created anymore
53
-
- Logging from interactive commands (absence of `--non-interactive`) was
54
-
improved.
55
-
- Passing `sources.nixpkgs` directly from npins to `meta.nixpkgs` has
56
-
been fixed.
97
+
- Fix bug where `--non-interactive` was inversed.
98
+
- Fix a bug where `./result` links where being created.
99
+
- Fix passing `sources.nixpkgs` directly from npins to `meta.nixpkgs`.
100
+
- Fix nodes that will be applied locally running the `push` and `cleanup`
101
+
steps.
57
102
58
103
### Changed
59
104
60
-
- Logs with level `tracing_level::TRACE` are compiled out of release builds
61
-
- Data integrity of keys have been greatly improved
105
+
- Improve logging from interactive commands (absence of `--non-interactive`).
106
+
- Changed `--path` argument to support flakerefs (`github:foo/bar`,
107
+
`git+file:///...`, `https://.../main.tar.gz`, etc).
108
+
- Changed SSH arguments to use ControlMaster by default.
109
+
- Compile-out logs with level `tracing_level::TRACE` in release builds.
110
+
- Improve aata integrity of keys.
62
111
- Unknown SSH keys will be immediately rejected unless `--ssh-accept-host` is passed.
63
-
- Logging was improved.
64
-
- `config.nixpkgs.flake.source` is now set by default if `meta.nixpkgs` ends
65
-
with `-source` at priority 1000 (default).
66
-
- Evaluation has been sped up by doing it in parallel with other steps until
67
-
the .drv is required
68
-
- A node which is going to be applied locally will now never `push` or
69
-
`cleanup`.
70
-
71
-
### Documented
72
-
73
-
- Added a real tutorial, and separated many how-to guides.
74
-
The tutorial leads the user through creating and deploying a wire Hive.
112
+
- Changed evaluation to be ran in parallel with other steps until
113
+
the .drv is required.
75
114
76
115
## [0.5.0] - 2025-09-18
77
116
+143
-105
Cargo.lock
+143
-105
Cargo.lock
···
18
18
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
19
19
20
20
[[package]]
21
-
name = "agent"
22
-
version = "1.0.0-beta.0"
23
-
dependencies = [
24
-
"anyhow",
25
-
"base64",
26
-
"futures-util",
27
-
"nix 0.30.1",
28
-
"prost",
29
-
"prost-build",
30
-
"sha2",
31
-
"tokio",
32
-
"tokio-util",
33
-
]
34
-
35
-
[[package]]
36
21
name = "aho-corasick"
37
22
version = "1.1.4"
38
23
source = "registry+https://github.com/rust-lang/crates.io-index"
···
292
277
293
278
[[package]]
294
279
name = "clap_complete"
295
-
version = "4.5.61"
280
+
version = "4.5.62"
296
281
source = "registry+https://github.com/rust-lang/crates.io-index"
297
-
checksum = "39615915e2ece2550c0149addac32fb5bd312c657f43845bb9088cb9c8a7c992"
282
+
checksum = "004eef6b14ce34759aa7de4aea3217e368f463f46a3ed3764ca4b5a4404003b4"
298
283
dependencies = [
299
284
"clap",
300
285
"clap_lex",
···
311
296
"heck",
312
297
"proc-macro2",
313
298
"quote",
314
-
"syn 2.0.110",
299
+
"syn 2.0.111",
315
300
]
316
301
317
302
[[package]]
···
342
327
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
343
328
344
329
[[package]]
330
+
name = "convert_case"
331
+
version = "0.10.0"
332
+
source = "registry+https://github.com/rust-lang/crates.io-index"
333
+
checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
334
+
dependencies = [
335
+
"unicode-segmentation",
336
+
]
337
+
338
+
[[package]]
345
339
name = "cpufeatures"
346
340
version = "0.2.17"
347
341
source = "registry+https://github.com/rust-lang/crates.io-index"
···
352
346
353
347
[[package]]
354
348
name = "crc"
355
-
version = "3.4.0"
349
+
version = "3.3.0"
356
350
source = "registry+https://github.com/rust-lang/crates.io-index"
357
-
checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
351
+
checksum = "9710d3b3739c2e349eb44fe848ad0b7c8cb1e42bd87ee49371df2f7acaf3e675"
358
352
dependencies = [
359
353
"crc-catalog",
360
354
]
···
414
408
dependencies = [
415
409
"proc-macro2",
416
410
"quote",
417
-
"syn 2.0.110",
411
+
"syn 2.0.111",
418
412
]
419
413
420
414
[[package]]
···
438
432
"proc-macro2",
439
433
"quote",
440
434
"strsim",
441
-
"syn 2.0.110",
435
+
"syn 2.0.111",
442
436
]
443
437
444
438
[[package]]
···
449
443
dependencies = [
450
444
"darling_core",
451
445
"quote",
452
-
"syn 2.0.110",
446
+
"syn 2.0.111",
453
447
]
454
448
455
449
[[package]]
···
471
465
472
466
[[package]]
473
467
name = "derive_more"
474
-
version = "2.0.1"
468
+
version = "2.1.0"
475
469
source = "registry+https://github.com/rust-lang/crates.io-index"
476
-
checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
470
+
checksum = "10b768e943bed7bf2cab53df09f4bc34bfd217cdb57d971e769874c9a6710618"
477
471
dependencies = [
478
472
"derive_more-impl",
479
473
]
480
474
481
475
[[package]]
482
476
name = "derive_more-impl"
483
-
version = "2.0.1"
477
+
version = "2.1.0"
484
478
source = "registry+https://github.com/rust-lang/crates.io-index"
485
-
checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
479
+
checksum = "6d286bfdaf75e988b4a78e013ecd79c581e06399ab53fbacd2d916c2f904f30b"
486
480
dependencies = [
481
+
"convert_case",
487
482
"proc-macro2",
488
483
"quote",
489
-
"syn 2.0.110",
484
+
"rustc_version",
485
+
"syn 2.0.111",
490
486
"unicode-xid",
491
487
]
492
488
···
526
522
dependencies = [
527
523
"proc-macro2",
528
524
"quote",
529
-
"syn 2.0.110",
525
+
"syn 2.0.111",
530
526
]
531
527
532
528
[[package]]
···
594
590
"once_cell",
595
591
"proc-macro2",
596
592
"quote",
597
-
"syn 2.0.110",
593
+
"syn 2.0.111",
598
594
]
599
595
600
596
[[package]]
···
610
606
checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
611
607
dependencies = [
612
608
"libc",
613
-
"windows-sys 0.60.2",
609
+
"windows-sys 0.52.0",
614
610
]
615
611
616
612
[[package]]
···
775
771
dependencies = [
776
772
"proc-macro2",
777
773
"quote",
778
-
"syn 2.0.110",
774
+
"syn 2.0.111",
779
775
]
780
776
781
777
[[package]]
···
1133
1129
]
1134
1130
1135
1131
[[package]]
1136
-
name = "lib"
1137
-
version = "1.0.0-beta.0"
1138
-
dependencies = [
1139
-
"agent",
1140
-
"aho-corasick",
1141
-
"anyhow",
1142
-
"base64",
1143
-
"derive_more",
1144
-
"enum_dispatch",
1145
-
"futures",
1146
-
"gethostname",
1147
-
"gjson",
1148
-
"im",
1149
-
"itertools",
1150
-
"miette",
1151
-
"nix 0.30.1",
1152
-
"nix-compat",
1153
-
"num_enum",
1154
-
"owo-colors",
1155
-
"portable-pty",
1156
-
"proc-macro2",
1157
-
"prost",
1158
-
"rand 0.9.2",
1159
-
"serde",
1160
-
"serde_json",
1161
-
"sha2",
1162
-
"sqlx",
1163
-
"strip-ansi-escapes",
1164
-
"syn 2.0.110",
1165
-
"tempdir",
1166
-
"termion",
1167
-
"thiserror 2.0.17",
1168
-
"tokio",
1169
-
"tokio-util",
1170
-
"tracing",
1171
-
"zstd",
1172
-
]
1173
-
1174
-
[[package]]
1175
1132
name = "libc"
1176
1133
version = "0.2.175"
1177
1134
source = "registry+https://github.com/rust-lang/crates.io-index"
···
1286
1243
dependencies = [
1287
1244
"proc-macro2",
1288
1245
"quote",
1289
-
"syn 2.0.110",
1246
+
"syn 2.0.111",
1290
1247
]
1291
1248
1292
1249
[[package]]
···
1388
1345
dependencies = [
1389
1346
"proc-macro2",
1390
1347
"quote",
1391
-
"syn 2.0.110",
1348
+
"syn 2.0.111",
1392
1349
]
1393
1350
1394
1351
[[package]]
···
1474
1431
"proc-macro-crate",
1475
1432
"proc-macro2",
1476
1433
"quote",
1477
-
"syn 2.0.110",
1434
+
"syn 2.0.111",
1478
1435
]
1479
1436
1480
1437
[[package]]
···
1653
1610
checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2"
1654
1611
dependencies = [
1655
1612
"proc-macro2",
1656
-
"syn 2.0.110",
1613
+
"syn 2.0.111",
1657
1614
]
1658
1615
1659
1616
[[package]]
···
1700
1657
"prost",
1701
1658
"prost-types",
1702
1659
"regex",
1703
-
"syn 2.0.110",
1660
+
"syn 2.0.111",
1704
1661
"tempfile",
1705
1662
]
1706
1663
···
1714
1671
"itertools",
1715
1672
"proc-macro2",
1716
1673
"quote",
1717
-
"syn 2.0.110",
1674
+
"syn 2.0.111",
1718
1675
]
1719
1676
1720
1677
[[package]]
···
1944
1901
"errno",
1945
1902
"libc",
1946
1903
"linux-raw-sys",
1947
-
"windows-sys 0.60.2",
1904
+
"windows-sys 0.52.0",
1948
1905
]
1949
1906
1950
1907
[[package]]
···
1998
1955
dependencies = [
1999
1956
"proc-macro2",
2000
1957
"quote",
2001
-
"syn 2.0.110",
1958
+
"syn 2.0.111",
2002
1959
]
2003
1960
2004
1961
[[package]]
···
2045
2002
"darling",
2046
2003
"proc-macro2",
2047
2004
"quote",
2048
-
"syn 2.0.110",
2005
+
"syn 2.0.111",
2049
2006
]
2050
2007
2051
2008
[[package]]
···
2113
2070
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
2114
2071
2115
2072
[[package]]
2073
+
name = "signal-hook"
2074
+
version = "0.3.18"
2075
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2076
+
checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
2077
+
dependencies = [
2078
+
"libc",
2079
+
"signal-hook-registry",
2080
+
]
2081
+
2082
+
[[package]]
2116
2083
name = "signal-hook-registry"
2117
2084
version = "1.4.6"
2118
2085
source = "registry+https://github.com/rust-lang/crates.io-index"
2119
2086
checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
2120
2087
dependencies = [
2121
2088
"libc",
2089
+
]
2090
+
2091
+
[[package]]
2092
+
name = "signal-hook-tokio"
2093
+
version = "0.3.1"
2094
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2095
+
checksum = "213241f76fb1e37e27de3b6aa1b068a2c333233b59cca6634f634b80a27ecf1e"
2096
+
dependencies = [
2097
+
"futures-core",
2098
+
"libc",
2099
+
"signal-hook",
2100
+
"tokio",
2122
2101
]
2123
2102
2124
2103
[[package]]
···
2242
2221
"quote",
2243
2222
"sqlx-core",
2244
2223
"sqlx-macros-core",
2245
-
"syn 2.0.110",
2224
+
"syn 2.0.111",
2246
2225
]
2247
2226
2248
2227
[[package]]
···
2265
2244
"sqlx-mysql",
2266
2245
"sqlx-postgres",
2267
2246
"sqlx-sqlite",
2268
-
"syn 2.0.110",
2247
+
"syn 2.0.111",
2269
2248
"tokio",
2270
2249
"url",
2271
2250
]
···
2455
2434
2456
2435
[[package]]
2457
2436
name = "syn"
2458
-
version = "2.0.110"
2437
+
version = "2.0.111"
2459
2438
source = "registry+https://github.com/rust-lang/crates.io-index"
2460
-
checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
2439
+
checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
2461
2440
dependencies = [
2462
2441
"proc-macro2",
2463
2442
"quote",
···
2472
2451
dependencies = [
2473
2452
"proc-macro2",
2474
2453
"quote",
2475
-
"syn 2.0.110",
2454
+
"syn 2.0.111",
2476
2455
]
2477
2456
2478
2457
[[package]]
···
2554
2533
dependencies = [
2555
2534
"proc-macro2",
2556
2535
"quote",
2557
-
"syn 2.0.110",
2536
+
"syn 2.0.111",
2558
2537
]
2559
2538
2560
2539
[[package]]
···
2565
2544
dependencies = [
2566
2545
"proc-macro2",
2567
2546
"quote",
2568
-
"syn 2.0.110",
2547
+
"syn 2.0.111",
2569
2548
]
2570
2549
2571
2550
[[package]]
···
2633
2612
dependencies = [
2634
2613
"proc-macro2",
2635
2614
"quote",
2636
-
"syn 2.0.110",
2615
+
"syn 2.0.111",
2637
2616
]
2638
2617
2639
2618
[[package]]
···
2692
2671
2693
2672
[[package]]
2694
2673
name = "tracing"
2695
-
version = "0.1.41"
2674
+
version = "0.1.44"
2696
2675
source = "registry+https://github.com/rust-lang/crates.io-index"
2697
-
checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
2676
+
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
2698
2677
dependencies = [
2699
2678
"log",
2700
2679
"pin-project-lite",
···
2704
2683
2705
2684
[[package]]
2706
2685
name = "tracing-attributes"
2707
-
version = "0.1.30"
2686
+
version = "0.1.31"
2708
2687
source = "registry+https://github.com/rust-lang/crates.io-index"
2709
-
checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
2688
+
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
2710
2689
dependencies = [
2711
2690
"proc-macro2",
2712
2691
"quote",
2713
-
"syn 2.0.110",
2692
+
"syn 2.0.111",
2714
2693
]
2715
2694
2716
2695
[[package]]
2717
2696
name = "tracing-core"
2718
-
version = "0.1.34"
2697
+
version = "0.1.36"
2719
2698
source = "registry+https://github.com/rust-lang/crates.io-index"
2720
-
checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
2699
+
checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
2721
2700
dependencies = [
2722
2701
"once_cell",
2723
2702
"valuable",
···
2736
2715
2737
2716
[[package]]
2738
2717
name = "tracing-subscriber"
2739
-
version = "0.3.20"
2718
+
version = "0.3.22"
2740
2719
source = "registry+https://github.com/rust-lang/crates.io-index"
2741
-
checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
2720
+
checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
2742
2721
dependencies = [
2743
2722
"nu-ansi-term",
2744
2723
"sharded-slab",
···
2786
2765
version = "0.1.4"
2787
2766
source = "registry+https://github.com/rust-lang/crates.io-index"
2788
2767
checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
2768
+
2769
+
[[package]]
2770
+
name = "unicode-segmentation"
2771
+
version = "1.12.0"
2772
+
source = "registry+https://github.com/rust-lang/crates.io-index"
2773
+
checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
2789
2774
2790
2775
[[package]]
2791
2776
name = "unicode-width"
···
3172
3157
3173
3158
[[package]]
3174
3159
name = "wire"
3175
-
version = "1.0.0-beta.0"
3160
+
version = "1.1.1"
3176
3161
dependencies = [
3177
3162
"clap",
3178
3163
"clap-markdown",
···
3182
3167
"dhat",
3183
3168
"enum-display-derive",
3184
3169
"futures",
3170
+
"itertools",
3171
+
"miette",
3172
+
"owo-colors",
3173
+
"serde_json",
3174
+
"signal-hook",
3175
+
"signal-hook-tokio",
3176
+
"thiserror 2.0.17",
3177
+
"tokio",
3178
+
"tracing",
3179
+
"tracing-log",
3180
+
"tracing-subscriber",
3181
+
"wire-core",
3182
+
]
3183
+
3184
+
[[package]]
3185
+
name = "wire-core"
3186
+
version = "1.1.1"
3187
+
dependencies = [
3188
+
"aho-corasick",
3189
+
"anyhow",
3190
+
"base64",
3191
+
"derive_more",
3192
+
"enum_dispatch",
3193
+
"futures",
3194
+
"gethostname",
3195
+
"gjson",
3185
3196
"im",
3186
3197
"itertools",
3187
-
"lib",
3188
3198
"miette",
3199
+
"nix 0.30.1",
3189
3200
"nix-compat",
3201
+
"num_enum",
3190
3202
"owo-colors",
3203
+
"portable-pty",
3204
+
"proc-macro2",
3205
+
"prost",
3206
+
"rand 0.9.2",
3191
3207
"serde",
3192
3208
"serde_json",
3209
+
"sha2",
3210
+
"sqlx",
3211
+
"strip-ansi-escapes",
3212
+
"syn 2.0.111",
3213
+
"tempdir",
3214
+
"termion",
3193
3215
"thiserror 2.0.17",
3194
3216
"tokio",
3217
+
"tokio-util",
3195
3218
"tracing",
3196
-
"tracing-log",
3197
-
"tracing-subscriber",
3219
+
"wire-key-agent",
3220
+
"zstd",
3221
+
]
3222
+
3223
+
[[package]]
3224
+
name = "wire-key-agent"
3225
+
version = "1.1.1"
3226
+
dependencies = [
3227
+
"anyhow",
3228
+
"base64",
3229
+
"futures-util",
3230
+
"nix 0.30.1",
3231
+
"prost",
3232
+
"prost-build",
3233
+
"sha2",
3234
+
"tokio",
3235
+
"tokio-util",
3198
3236
]
3199
3237
3200
3238
[[package]]
···
3232
3270
dependencies = [
3233
3271
"proc-macro2",
3234
3272
"quote",
3235
-
"syn 2.0.110",
3273
+
"syn 2.0.111",
3236
3274
"synstructure",
3237
3275
]
3238
3276
···
3253
3291
dependencies = [
3254
3292
"proc-macro2",
3255
3293
"quote",
3256
-
"syn 2.0.110",
3294
+
"syn 2.0.111",
3257
3295
]
3258
3296
3259
3297
[[package]]
···
3273
3311
dependencies = [
3274
3312
"proc-macro2",
3275
3313
"quote",
3276
-
"syn 2.0.110",
3314
+
"syn 2.0.111",
3277
3315
"synstructure",
3278
3316
]
3279
3317
···
3313
3351
dependencies = [
3314
3352
"proc-macro2",
3315
3353
"quote",
3316
-
"syn 2.0.110",
3354
+
"syn 2.0.111",
3317
3355
]
3318
3356
3319
3357
[[package]]
+2
-2
Cargo.toml
+2
-2
Cargo.toml
···
1
1
[workspace]
2
-
members = ["wire/agent", "wire/lib", "wire/cli"]
2
+
members = ["crates/key_agent", "crates/core", "crates/cli"]
3
3
resolver = "2"
4
4
package.edition = "2024"
5
-
package.version = "1.0.0-beta.0"
5
+
package.version = "1.1.1"
6
6
7
7
[workspace.metadata.crane]
8
8
name = "wire"
+3
-39
README.md
+3
-39
README.md
···
1
-
2
-
3
-
1
+
2
+
3
+
4
4
5
5
wire is a tool to deploy nixos systems. its usage is inspired by colmena however it is not a fork.
6
6
7
7
Read the [The Tutorial](https://wire.althaea.zone/tutorial/overview.html), [Guides](https://wire.althaea.zone/guides/installation.html), or continue reading this readme for development information.
8
8
9
-
## Tree Layout
10
-
11
-
```
12
-
wire
13
-
โโโ wire
14
-
โ โโโ lib
15
-
โ โ โโโ Rust library containing business logic, consumed by `wire`
16
-
โ โโโ cli
17
-
โ โ โโโ Rust binary, using `lib`
18
-
โ โโโ agent
19
-
โ โโโ Rust binary ran on a target node. receives key file bytes and metadata w/ protobuf over SSH stdin
20
-
โโโ doc
21
-
โ โโโ a [vitepress](https://vitepress.dev/) site
22
-
โโโ runtime
23
-
โ โโโ Nix files used during runtime to evaluate nodes
24
-
โโโ bench
25
-
โ โโโ A little tool to benchmark wire against a large hive
26
-
โโโtests
27
-
โโโ Directories used during cargo & NixOS VM testing
28
-
```
29
-
30
9
## Development
31
10
32
11
Please use `nix develop` for access to the development environment and to ensure
33
12
your changes are ran against the defined git hooks. For simplicity, you may wish
34
13
to use [direnv](https://github.com/direnv/direnv).
35
-
36
-
### Testing
37
-
38
-
#### dhat profiling
39
-
40
-
```sh
41
-
$ just build-dhat
42
-
```
43
-
44
-
#### Testing
45
-
46
-
```sh
47
-
$ cargo test
48
-
$ nix flake check
49
-
```
+1
-3
bench/runner.nix
+1
-3
bench/runner.nix
+32
crates/cli/Cargo.toml
+32
crates/cli/Cargo.toml
···
1
+
[package]
2
+
name = "wire"
3
+
version.workspace = true
4
+
edition.workspace = true
5
+
6
+
[lints]
7
+
workspace = true
8
+
9
+
[features]
10
+
dhat-heap = []
11
+
12
+
[dependencies]
13
+
clap = { workspace = true }
14
+
clap-verbosity-flag = { workspace = true }
15
+
tokio = { workspace = true }
16
+
tracing = { workspace = true }
17
+
tracing-log = { workspace = true }
18
+
tracing-subscriber = { workspace = true }
19
+
wire-core = { path = "../core" }
20
+
serde_json = { workspace = true }
21
+
miette = { workspace = true }
22
+
thiserror = { workspace = true }
23
+
enum-display-derive = "0.1.1"
24
+
futures = "0.3.31"
25
+
clap-num = "1.2.0"
26
+
clap-markdown = "0.1.5"
27
+
itertools = "0.14.0"
28
+
dhat = "0.3.2"
29
+
clap_complete = { version = "4.5.60", features = ["unstable-dynamic"] }
30
+
owo-colors = { workspace = true }
31
+
signal-hook-tokio = { version = "0.3.1", features = ["futures-v0_3"] }
32
+
signal-hook = "0.3.18"
+98
crates/cli/default.nix
+98
crates/cli/default.nix
···
1
+
{ getSystem, inputs, ... }:
2
+
{
3
+
perSystem =
4
+
{
5
+
pkgs,
6
+
lib,
7
+
self',
8
+
buildRustProgram,
9
+
system,
10
+
...
11
+
}:
12
+
let
13
+
cleanSystem = system: lib.replaceStrings [ "-" ] [ "_" ] system;
14
+
agents = lib.strings.concatMapStrings (
15
+
system: "--set WIRE_KEY_AGENT_${cleanSystem system} ${(getSystem system).packages.agent} "
16
+
) (import inputs.linux-systems);
17
+
in
18
+
{
19
+
packages = {
20
+
default = self'.packages.wire;
21
+
wire-unwrapped = buildRustProgram {
22
+
name = "wire";
23
+
pname = "wire";
24
+
cargoExtraArgs = "-p wire";
25
+
doCheck = true;
26
+
nativeBuildInputs = [
27
+
pkgs.installShellFiles
28
+
pkgs.sqlx-cli
29
+
];
30
+
preBuild = ''
31
+
export DATABASE_URL=sqlite:./db.sqlite3
32
+
sqlx database create
33
+
sqlx migrate run --source ./crates/core/src/cache/migrations/
34
+
'';
35
+
postInstall = ''
36
+
installShellCompletion --cmd wire \
37
+
--bash <(COMPLETE=bash $out/bin/wire) \
38
+
--fish <(COMPLETE=fish $out/bin/wire) \
39
+
--zsh <(COMPLETE=zsh $out/bin/wire)
40
+
'';
41
+
};
42
+
43
+
wire-unwrapped-dev = self'.packages.wire-unwrapped.overrideAttrs {
44
+
CARGO_PROFILE = "dev";
45
+
};
46
+
47
+
wire-unwrapped-perf = buildRustProgram {
48
+
name = "wire";
49
+
pname = "wire";
50
+
CARGO_PROFILE = "profiling";
51
+
cargoExtraArgs = "-p wire";
52
+
};
53
+
54
+
wire = pkgs.symlinkJoin {
55
+
name = "wire";
56
+
paths = [ self'.packages.wire-unwrapped ];
57
+
nativeBuildInputs = [
58
+
pkgs.makeWrapper
59
+
];
60
+
postBuild = ''
61
+
wrapProgram $out/bin/wire ${agents}
62
+
'';
63
+
meta.mainProgram = "wire";
64
+
};
65
+
66
+
wire-small = pkgs.symlinkJoin {
67
+
name = "wire";
68
+
paths = [ self'.packages.wire-unwrapped ];
69
+
nativeBuildInputs = [
70
+
pkgs.makeWrapper
71
+
];
72
+
postBuild = ''
73
+
wrapProgram $out/bin/wire --set WIRE_KEY_AGENT_${cleanSystem system} ${self'.packages.agent}
74
+
'';
75
+
meta.mainProgram = "wire";
76
+
};
77
+
78
+
wire-dev = self'.packages.wire.overrideAttrs {
79
+
paths = [ self'.packages.wire-unwrapped-dev ];
80
+
};
81
+
82
+
wire-small-dev = self'.packages.wire-small.overrideAttrs {
83
+
paths = [ self'.packages.wire-unwrapped-dev ];
84
+
};
85
+
86
+
wire-small-perf = self'.packages.wire-small.overrideAttrs {
87
+
paths = [ self'.packages.wire-unwrapped-perf ];
88
+
};
89
+
90
+
wire-diagnostics-md = self'.packages.wire-unwrapped.overrideAttrs {
91
+
DIAGNOSTICS_MD_OUTPUT = "/build/source";
92
+
installPhase = ''
93
+
mv /build/source/DIAGNOSTICS.md $out
94
+
'';
95
+
};
96
+
};
97
+
};
98
+
}
+341
crates/cli/src/apply.rs
+341
crates/cli/src/apply.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use futures::{FutureExt, StreamExt};
5
+
use itertools::{Either, Itertools};
6
+
use miette::{Diagnostic, IntoDiagnostic, Result};
7
+
use std::any::Any;
8
+
use std::collections::HashSet;
9
+
use std::io::{Read, stderr};
10
+
use std::sync::Arc;
11
+
use std::sync::atomic::AtomicBool;
12
+
use thiserror::Error;
13
+
use tracing::{error, info};
14
+
use wire_core::hive::node::{Context, GoalExecutor, Name, Node, Objective, StepState};
15
+
use wire_core::hive::{Hive, HiveLocation};
16
+
use wire_core::status::STATUS;
17
+
use wire_core::{SubCommandModifiers, errors::HiveLibError};
18
+
19
+
use crate::cli::{ApplyTarget, CommonVerbArgs, Partitions};
20
+
21
+
#[derive(Debug, Error, Diagnostic)]
22
+
#[error("node {} failed to apply", .0)]
23
+
struct NodeError(
24
+
Name,
25
+
#[source]
26
+
#[diagnostic_source]
27
+
HiveLibError,
28
+
);
29
+
30
+
#[derive(Debug, Error, Diagnostic)]
31
+
#[error("{} node(s) failed to apply.", .0.len())]
32
+
struct NodeErrors(#[related] Vec<NodeError>);
33
+
34
+
// returns Names and Tags
35
+
fn read_apply_targets_from_stdin() -> Result<(Vec<String>, Vec<Name>)> {
36
+
let mut buf = String::new();
37
+
let mut stdin = std::io::stdin().lock();
38
+
stdin.read_to_string(&mut buf).into_diagnostic()?;
39
+
40
+
Ok(buf
41
+
.split_whitespace()
42
+
.map(|x| ApplyTarget::from(x.to_string()))
43
+
.fold((Vec::new(), Vec::new()), |(mut tags, mut names), target| {
44
+
match target {
45
+
ApplyTarget::Node(name) => names.push(name),
46
+
ApplyTarget::Tag(tag) => tags.push(tag),
47
+
ApplyTarget::Stdin => {}
48
+
}
49
+
(tags, names)
50
+
}))
51
+
}
52
+
53
+
fn resolve_targets(
54
+
on: &[ApplyTarget],
55
+
modifiers: &mut SubCommandModifiers,
56
+
) -> (HashSet<String>, HashSet<Name>) {
57
+
on.iter().fold(
58
+
(HashSet::new(), HashSet::new()),
59
+
|(mut tags, mut names), target| {
60
+
match target {
61
+
ApplyTarget::Tag(tag) => {
62
+
tags.insert(tag.clone());
63
+
}
64
+
ApplyTarget::Node(name) => {
65
+
names.insert(name.clone());
66
+
}
67
+
ApplyTarget::Stdin => {
68
+
// implies non_interactive
69
+
modifiers.non_interactive = true;
70
+
71
+
let (found_tags, found_names) = read_apply_targets_from_stdin().unwrap();
72
+
names.extend(found_names);
73
+
tags.extend(found_tags);
74
+
}
75
+
}
76
+
(tags, names)
77
+
},
78
+
)
79
+
}
80
+
81
+
fn partition_arr<T>(arr: Vec<T>, partition: &Partitions) -> Vec<T>
82
+
where
83
+
T: Any + Clone,
84
+
{
85
+
if arr.is_empty() {
86
+
return arr;
87
+
}
88
+
89
+
let items_per_chunk = arr.len().div_ceil(partition.maximum);
90
+
91
+
arr.chunks(items_per_chunk)
92
+
.nth(partition.current - 1)
93
+
.unwrap_or(&[])
94
+
.to_vec()
95
+
}
96
+
97
+
pub async fn apply<F>(
98
+
hive: &mut Hive,
99
+
should_shutdown: Arc<AtomicBool>,
100
+
location: HiveLocation,
101
+
args: CommonVerbArgs,
102
+
partition: Partitions,
103
+
make_objective: F,
104
+
mut modifiers: SubCommandModifiers,
105
+
) -> Result<()>
106
+
where
107
+
F: Fn(&Name, &Node) -> Objective,
108
+
{
109
+
let location = Arc::new(location);
110
+
111
+
let (tags, names) = resolve_targets(&args.on, &mut modifiers);
112
+
113
+
let selected_names: Vec<_> = hive
114
+
.nodes
115
+
.iter()
116
+
.filter(|(name, node)| {
117
+
args.on.is_empty()
118
+
|| names.contains(name)
119
+
|| node.tags.iter().any(|tag| tags.contains(tag))
120
+
})
121
+
.sorted_by_key(|(name, _)| *name)
122
+
.map(|(name, _)| name.clone())
123
+
.collect();
124
+
125
+
let num_selected = selected_names.len();
126
+
127
+
let partitioned_names = partition_arr(selected_names, &partition);
128
+
129
+
if num_selected != partitioned_names.len() {
130
+
info!(
131
+
"Partitioning reduced selected number of nodes from {num_selected} to {}",
132
+
partitioned_names.len()
133
+
);
134
+
}
135
+
136
+
STATUS
137
+
.lock()
138
+
.add_many(&partitioned_names.iter().collect::<Vec<_>>());
139
+
140
+
let mut set = hive
141
+
.nodes
142
+
.iter_mut()
143
+
.filter(|(name, _)| partitioned_names.contains(name))
144
+
.map(|(name, node)| {
145
+
info!("Resolved {:?} to include {}", args.on, name);
146
+
147
+
let objective = make_objective(name, node);
148
+
149
+
let context = Context {
150
+
node,
151
+
name,
152
+
objective,
153
+
state: StepState::default(),
154
+
hive_location: location.clone(),
155
+
modifiers,
156
+
should_quit: should_shutdown.clone(),
157
+
};
158
+
159
+
GoalExecutor::new(context)
160
+
.execute()
161
+
.map(move |result| (name, result))
162
+
})
163
+
.peekable();
164
+
165
+
if set.peek().is_none() {
166
+
error!("There are no nodes selected for deployment");
167
+
}
168
+
169
+
let futures = futures::stream::iter(set).buffer_unordered(args.parallel);
170
+
let result = futures.collect::<Vec<_>>().await;
171
+
let (successful, errors): (Vec<_>, Vec<_>) =
172
+
result
173
+
.into_iter()
174
+
.partition_map(|(name, result)| match result {
175
+
Ok(..) => Either::Left(name),
176
+
Err(err) => Either::Right((name, err)),
177
+
});
178
+
179
+
if !successful.is_empty() {
180
+
info!(
181
+
"Successfully applied goal to {} node(s): {:?}",
182
+
successful.len(),
183
+
successful
184
+
);
185
+
}
186
+
187
+
if !errors.is_empty() {
188
+
// clear the status bar if we are about to print error messages
189
+
STATUS.lock().clear(&mut stderr());
190
+
191
+
return Err(NodeErrors(
192
+
errors
193
+
.into_iter()
194
+
.map(|(name, error)| NodeError(name.clone(), error))
195
+
.collect(),
196
+
)
197
+
.into());
198
+
}
199
+
200
+
Ok(())
201
+
}
202
+
203
+
#[cfg(test)]
204
+
mod tests {
205
+
use super::*;
206
+
207
+
#[test]
208
+
#[allow(clippy::too_many_lines)]
209
+
fn test_partitioning() {
210
+
let arr = (1..=10).collect::<Vec<_>>();
211
+
assert_eq!(arr, partition_arr(arr.clone(), &Partitions::default()));
212
+
213
+
assert_eq!(
214
+
vec![1, 2, 3, 4, 5],
215
+
partition_arr(
216
+
arr.clone(),
217
+
&Partitions {
218
+
current: 1,
219
+
maximum: 2
220
+
}
221
+
)
222
+
);
223
+
assert_eq!(
224
+
vec![6, 7, 8, 9, 10],
225
+
partition_arr(
226
+
arr,
227
+
&Partitions {
228
+
current: 2,
229
+
maximum: 2
230
+
}
231
+
)
232
+
);
233
+
234
+
// test odd number
235
+
let arr = (1..10).collect::<Vec<_>>();
236
+
assert_eq!(
237
+
arr.clone(),
238
+
partition_arr(arr.clone(), &Partitions::default())
239
+
);
240
+
241
+
assert_eq!(
242
+
vec![1, 2, 3, 4, 5],
243
+
partition_arr(
244
+
arr.clone(),
245
+
&Partitions {
246
+
current: 1,
247
+
maximum: 2
248
+
}
249
+
)
250
+
);
251
+
assert_eq!(
252
+
vec![6, 7, 8, 9],
253
+
partition_arr(
254
+
arr.clone(),
255
+
&Partitions {
256
+
current: 2,
257
+
maximum: 2
258
+
}
259
+
)
260
+
);
261
+
262
+
// test large number of partitions
263
+
let arr = (1..=10).collect::<Vec<_>>();
264
+
assert_eq!(
265
+
arr.clone(),
266
+
partition_arr(arr.clone(), &Partitions::default())
267
+
);
268
+
269
+
for i in 1..=10 {
270
+
assert_eq!(
271
+
vec![i],
272
+
partition_arr(
273
+
arr.clone(),
274
+
&Partitions {
275
+
current: i,
276
+
maximum: 10
277
+
}
278
+
)
279
+
);
280
+
281
+
assert_eq!(
282
+
vec![i],
283
+
partition_arr(
284
+
arr.clone(),
285
+
&Partitions {
286
+
current: i,
287
+
maximum: 15
288
+
}
289
+
)
290
+
);
291
+
}
292
+
293
+
// stretching thin with higher partitions will start to leave higher ones empty
294
+
assert_eq!(
295
+
Vec::<usize>::new(),
296
+
partition_arr(
297
+
arr,
298
+
&Partitions {
299
+
current: 11,
300
+
maximum: 15
301
+
}
302
+
)
303
+
);
304
+
305
+
// test the above holds for a lot of numbers
306
+
for i in 1..1000 {
307
+
let arr: Vec<usize> = (0..i).collect();
308
+
let total = arr.len();
309
+
310
+
assert_eq!(
311
+
arr.clone(),
312
+
partition_arr(arr.clone(), &Partitions::default()),
313
+
);
314
+
315
+
let buckets = 2;
316
+
let chunk_size = total.div_ceil(buckets);
317
+
let split_index = std::cmp::min(chunk_size, total);
318
+
319
+
assert_eq!(
320
+
&arr.clone()[..split_index],
321
+
partition_arr(
322
+
arr.clone(),
323
+
&Partitions {
324
+
current: 1,
325
+
maximum: 2
326
+
}
327
+
),
328
+
);
329
+
assert_eq!(
330
+
&arr.clone()[split_index..],
331
+
partition_arr(
332
+
arr.clone(),
333
+
&Partitions {
334
+
current: 2,
335
+
maximum: 2
336
+
}
337
+
),
338
+
);
339
+
}
340
+
}
341
+
}
+398
crates/cli/src/cli.rs
+398
crates/cli/src/cli.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use clap::builder::PossibleValue;
5
+
use clap::{Args, Parser, Subcommand, ValueEnum};
6
+
use clap::{ValueHint, crate_version};
7
+
use clap_complete::CompletionCandidate;
8
+
use clap_complete::engine::ArgValueCompleter;
9
+
use clap_num::number_range;
10
+
use clap_verbosity_flag::InfoLevel;
11
+
use tokio::runtime::Handle;
12
+
use wire_core::SubCommandModifiers;
13
+
use wire_core::commands::common::get_hive_node_names;
14
+
use wire_core::hive::node::{Goal as HiveGoal, HandleUnreachable, Name, SwitchToConfigurationGoal};
15
+
use wire_core::hive::{Hive, get_hive_location};
16
+
17
+
use std::io::IsTerminal;
18
+
use std::{
19
+
fmt::{self, Display, Formatter},
20
+
sync::Arc,
21
+
};
22
+
23
+
#[allow(clippy::struct_excessive_bools)]
24
+
#[derive(Parser)]
25
+
#[command(
26
+
name = "wire",
27
+
bin_name = "wire",
28
+
about = "a tool to deploy nixos systems",
29
+
version = format!("{}\nDebug: Hive::SCHEMA_VERSION {}", crate_version!(), Hive::SCHEMA_VERSION)
30
+
)]
31
+
pub struct Cli {
32
+
#[command(subcommand)]
33
+
pub command: Commands,
34
+
35
+
#[command(flatten)]
36
+
pub verbose: clap_verbosity_flag::Verbosity<InfoLevel>,
37
+
38
+
/// Path or flake reference
39
+
#[arg(long, global = true, default_value = std::env::current_dir().unwrap().into_os_string(), visible_alias("flake"))]
40
+
pub path: String,
41
+
42
+
/// Hide progress bars.
43
+
///
44
+
/// Defaults to true if stdin does not refer to a tty (unix pipelines, in CI).
45
+
#[arg(long, global = true, default_value_t = !std::io::stdin().is_terminal())]
46
+
pub no_progress: bool,
47
+
48
+
/// Never accept user input.
49
+
///
50
+
/// Defaults to true if stdin does not refer to a tty (unix pipelines, in CI).
51
+
#[arg(long, global = true, default_value_t = !std::io::stdin().is_terminal())]
52
+
pub non_interactive: bool,
53
+
54
+
/// Show trace logs
55
+
#[arg(long, global = true, default_value_t = false)]
56
+
pub show_trace: bool,
57
+
58
+
#[cfg(debug_assertions)]
59
+
#[arg(long, hide = true, global = true)]
60
+
pub markdown_help: bool,
61
+
}
62
+
63
+
#[derive(Clone, Debug)]
64
+
pub enum ApplyTarget {
65
+
Node(Name),
66
+
Tag(String),
67
+
Stdin,
68
+
}
69
+
70
+
impl From<String> for ApplyTarget {
71
+
fn from(value: String) -> Self {
72
+
if value == "-" {
73
+
return ApplyTarget::Stdin;
74
+
}
75
+
76
+
if let Some(stripped) = value.strip_prefix("@") {
77
+
ApplyTarget::Tag(stripped.to_string())
78
+
} else {
79
+
ApplyTarget::Node(Name(Arc::from(value.as_str())))
80
+
}
81
+
}
82
+
}
83
+
84
+
impl Display for ApplyTarget {
85
+
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
86
+
match self {
87
+
ApplyTarget::Node(name) => name.fmt(f),
88
+
ApplyTarget::Tag(tag) => write!(f, "@{tag}"),
89
+
ApplyTarget::Stdin => write!(f, "#stdin"),
90
+
}
91
+
}
92
+
}
93
+
94
+
fn more_than_zero(s: &str) -> Result<usize, String> {
95
+
number_range(s, 1, usize::MAX)
96
+
}
97
+
98
+
fn parse_partitions(s: &str) -> Result<Partitions, String> {
99
+
let parts: [&str; 2] = s
100
+
.split('/')
101
+
.collect::<Vec<_>>()
102
+
.try_into()
103
+
.map_err(|_| "partition must contain exactly one '/'")?;
104
+
105
+
let (current, maximum) =
106
+
std::array::from_fn(|i| parts[i].parse::<usize>().map_err(|x| x.to_string())).into();
107
+
let (current, maximum) = (current?, maximum?);
108
+
109
+
if current > maximum {
110
+
return Err("current is more than total".to_string());
111
+
}
112
+
113
+
if current == 0 || maximum == 0 {
114
+
return Err("partition segments cannot be 0.".to_string());
115
+
}
116
+
117
+
Ok(Partitions { current, maximum })
118
+
}
119
+
120
+
#[derive(Clone)]
121
+
pub enum HandleUnreachableArg {
122
+
Ignore,
123
+
FailNode,
124
+
}
125
+
126
+
impl Display for HandleUnreachableArg {
127
+
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
128
+
match self {
129
+
Self::Ignore => write!(f, "ignore"),
130
+
Self::FailNode => write!(f, "fail-node"),
131
+
}
132
+
}
133
+
}
134
+
135
+
impl clap::ValueEnum for HandleUnreachableArg {
136
+
fn value_variants<'a>() -> &'a [Self] {
137
+
&[Self::Ignore, Self::FailNode]
138
+
}
139
+
140
+
fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
141
+
match self {
142
+
Self::Ignore => Some(PossibleValue::new("ignore")),
143
+
Self::FailNode => Some(PossibleValue::new("fail-node")),
144
+
}
145
+
}
146
+
}
147
+
148
+
impl From<HandleUnreachableArg> for HandleUnreachable {
149
+
fn from(value: HandleUnreachableArg) -> Self {
150
+
match value {
151
+
HandleUnreachableArg::Ignore => Self::Ignore,
152
+
HandleUnreachableArg::FailNode => Self::FailNode,
153
+
}
154
+
}
155
+
}
156
+
157
+
#[derive(Args)]
158
+
pub struct CommonVerbArgs {
159
+
/// List of literal node names, a literal `-`, or `@` prefixed tags.
160
+
///
161
+
/// `-` will read additional values from stdin, separated by whitespace.
162
+
/// Any `-` implies `--non-interactive`.
163
+
#[arg(short, long, value_name = "NODE | @TAG | `-`", num_args = 1.., add = ArgValueCompleter::new(node_names_completer), value_hint = ValueHint::Unknown)]
164
+
pub on: Vec<ApplyTarget>,
165
+
166
+
#[arg(short, long, default_value_t = 10, value_parser=more_than_zero)]
167
+
pub parallel: usize,
168
+
}
169
+
170
+
#[allow(clippy::struct_excessive_bools)]
171
+
#[derive(Args)]
172
+
pub struct ApplyArgs {
173
+
#[command(flatten)]
174
+
pub common: CommonVerbArgs,
175
+
176
+
#[arg(value_enum, default_value_t)]
177
+
pub goal: Goal,
178
+
179
+
/// Skip key uploads. noop when [GOAL] = Keys
180
+
#[arg(short, long, default_value_t = false)]
181
+
pub no_keys: bool,
182
+
183
+
/// Overrides deployment.buildOnTarget.
184
+
#[arg(short, long, value_name = "NODE")]
185
+
pub always_build_local: Vec<String>,
186
+
187
+
/// Reboot the nodes after activation
188
+
#[arg(short, long, default_value_t = false)]
189
+
pub reboot: bool,
190
+
191
+
/// Enable `--substitute-on-destination` in Nix subcommands.
192
+
#[arg(short, long, default_value_t = true)]
193
+
pub substitute_on_destination: bool,
194
+
195
+
/// How to handle an unreachable node in the ping step.
196
+
///
197
+
/// This only effects the ping step.
198
+
/// wire will still fail the node if it becomes unreachable after activation
199
+
#[arg(long, default_value_t = HandleUnreachableArg::FailNode)]
200
+
pub handle_unreachable: HandleUnreachableArg,
201
+
202
+
/// Unconditionally accept SSH host keys [!!]
203
+
///
204
+
/// Sets `StrictHostKeyChecking` to `no`.
205
+
/// Vulnerable to man-in-the-middle attacks, use with caution.
206
+
#[arg(long, default_value_t = false)]
207
+
pub ssh_accept_host: bool,
208
+
}
209
+
210
+
#[derive(Clone, Debug)]
211
+
pub struct Partitions {
212
+
pub current: usize,
213
+
pub maximum: usize,
214
+
}
215
+
216
+
impl Default for Partitions {
217
+
fn default() -> Self {
218
+
Self {
219
+
current: 1,
220
+
maximum: 1,
221
+
}
222
+
}
223
+
}
224
+
225
+
#[derive(Args)]
226
+
pub struct BuildArgs {
227
+
#[command(flatten)]
228
+
pub common: CommonVerbArgs,
229
+
230
+
/// Partition builds into buckets.
231
+
///
232
+
/// In the format of `current/total`, where 1 <= current <= total.
233
+
#[arg(short = 'P', default_value="1/1", long, value_parser=parse_partitions)]
234
+
pub partition: Option<Partitions>,
235
+
}
236
+
237
+
#[derive(Subcommand)]
238
+
pub enum Commands {
239
+
/// Deploy nodes
240
+
Apply(ApplyArgs),
241
+
/// Build nodes offline
242
+
///
243
+
/// This is distinct from `wire apply build`, as it will not ping or push
244
+
/// the result, making it useful for CI.
245
+
///
246
+
/// Additionally, you may partition the build jobs into buckets.
247
+
Build(BuildArgs),
248
+
/// Inspect hive
249
+
#[clap(visible_alias = "show")]
250
+
Inspect {
251
+
#[arg(value_enum, default_value_t)]
252
+
selection: Inspection,
253
+
254
+
/// Return in JSON format
255
+
#[arg(short, long, default_value_t = false)]
256
+
json: bool,
257
+
},
258
+
}
259
+
260
+
#[derive(Clone, Debug, Default, ValueEnum, Display)]
261
+
pub enum Inspection {
262
+
/// Output all data wire has on the entire hive
263
+
#[default]
264
+
Full,
265
+
/// Only output a list of node names
266
+
Names,
267
+
}
268
+
269
+
#[derive(Clone, Debug, Default, ValueEnum, Display)]
270
+
pub enum Goal {
271
+
/// Make the configuration the boot default and activate now
272
+
#[default]
273
+
Switch,
274
+
/// Build the configuration & push the results
275
+
Build,
276
+
/// Copy the system derivation to the remote hosts
277
+
Push,
278
+
/// Push deployment keys to the remote hosts
279
+
Keys,
280
+
/// Activate the system profile on next boot
281
+
Boot,
282
+
/// Activate the configuration, but don't make it the boot default
283
+
Test,
284
+
/// Show what would be done if this configuration were activated.
285
+
DryActivate,
286
+
}
287
+
288
+
impl TryFrom<Goal> for HiveGoal {
289
+
type Error = miette::Error;
290
+
291
+
fn try_from(value: Goal) -> Result<Self, Self::Error> {
292
+
match value {
293
+
Goal::Build => Ok(HiveGoal::Build),
294
+
Goal::Push => Ok(HiveGoal::Push),
295
+
Goal::Boot => Ok(HiveGoal::SwitchToConfiguration(
296
+
SwitchToConfigurationGoal::Boot,
297
+
)),
298
+
Goal::Switch => Ok(HiveGoal::SwitchToConfiguration(
299
+
SwitchToConfigurationGoal::Switch,
300
+
)),
301
+
Goal::Test => Ok(HiveGoal::SwitchToConfiguration(
302
+
SwitchToConfigurationGoal::Test,
303
+
)),
304
+
Goal::DryActivate => Ok(HiveGoal::SwitchToConfiguration(
305
+
SwitchToConfigurationGoal::DryActivate,
306
+
)),
307
+
Goal::Keys => Ok(HiveGoal::Keys),
308
+
}
309
+
}
310
+
}
311
+
312
+
pub trait ToSubCommandModifiers {
313
+
fn to_subcommand_modifiers(&self) -> SubCommandModifiers;
314
+
}
315
+
316
+
impl ToSubCommandModifiers for Cli {
317
+
fn to_subcommand_modifiers(&self) -> SubCommandModifiers {
318
+
SubCommandModifiers {
319
+
show_trace: self.show_trace,
320
+
non_interactive: self.non_interactive,
321
+
ssh_accept_host: match &self.command {
322
+
Commands::Apply(args) if args.ssh_accept_host => {
323
+
wire_core::StrictHostKeyChecking::No
324
+
}
325
+
_ => wire_core::StrictHostKeyChecking::default(),
326
+
},
327
+
}
328
+
}
329
+
}
330
+
331
+
fn node_names_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidate> {
332
+
tokio::task::block_in_place(|| {
333
+
let handle = Handle::current();
334
+
let modifiers = SubCommandModifiers::default();
335
+
let mut completions = vec![];
336
+
337
+
if current.is_empty() || current == "-" {
338
+
completions.push(
339
+
CompletionCandidate::new("-").help(Some("Read stdin as --on arguments".into())),
340
+
);
341
+
}
342
+
343
+
let Ok(current_dir) = std::env::current_dir() else {
344
+
return completions;
345
+
};
346
+
347
+
let Ok(hive_location) = handle.block_on(get_hive_location(
348
+
current_dir.display().to_string(),
349
+
modifiers,
350
+
)) else {
351
+
return completions;
352
+
};
353
+
354
+
let Some(current) = current.to_str() else {
355
+
return completions;
356
+
};
357
+
358
+
if current.starts_with('@') {
359
+
return vec![];
360
+
}
361
+
362
+
if let Ok(names) =
363
+
handle.block_on(async { get_hive_node_names(&hive_location, modifiers).await })
364
+
{
365
+
for name in names {
366
+
if name.starts_with(current) {
367
+
completions.push(CompletionCandidate::new(name));
368
+
}
369
+
}
370
+
}
371
+
372
+
completions
373
+
})
374
+
}
375
+
376
+
#[cfg(test)]
377
+
mod tests {
378
+
use std::assert_matches::assert_matches;
379
+
380
+
use crate::cli::{Partitions, parse_partitions};
381
+
382
+
#[test]
383
+
fn test_partition_parsing() {
384
+
assert_matches!(parse_partitions(""), Err(..));
385
+
assert_matches!(parse_partitions("/"), Err(..));
386
+
assert_matches!(parse_partitions(" / "), Err(..));
387
+
assert_matches!(parse_partitions("abc/"), Err(..));
388
+
assert_matches!(parse_partitions("abc"), Err(..));
389
+
assert_matches!(parse_partitions("1/1"), Ok(Partitions {
390
+
current,
391
+
maximum
392
+
}) if current == 1 && maximum == 1);
393
+
assert_matches!(parse_partitions("0/1"), Err(..));
394
+
assert_matches!(parse_partitions("-11/1"), Err(..));
395
+
assert_matches!(parse_partitions("100/99"), Err(..));
396
+
assert_matches!(parse_partitions("5/10"), Ok(Partitions { current, maximum }) if current == 5 && maximum == 10);
397
+
}
398
+
}
+173
crates/cli/src/main.rs
+173
crates/cli/src/main.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#![deny(clippy::pedantic)]
5
+
#![feature(sync_nonpoison)]
6
+
#![feature(nonpoison_mutex)]
7
+
#![feature(assert_matches)]
8
+
9
+
use std::process::Command;
10
+
use std::sync::Arc;
11
+
use std::sync::atomic::AtomicBool;
12
+
13
+
use crate::cli::Cli;
14
+
use crate::cli::Partitions;
15
+
use crate::cli::ToSubCommandModifiers;
16
+
use crate::sigint::handle_signals;
17
+
use crate::tracing_setup::setup_logging;
18
+
use clap::CommandFactory;
19
+
use clap::Parser;
20
+
use clap_complete::CompleteEnv;
21
+
use miette::IntoDiagnostic;
22
+
use miette::Result;
23
+
use signal_hook::consts::SIGINT;
24
+
use signal_hook_tokio::Signals;
25
+
use tracing::error;
26
+
use tracing::warn;
27
+
use wire_core::cache::InspectionCache;
28
+
use wire_core::commands::common::get_hive_node_names;
29
+
use wire_core::hive::Hive;
30
+
use wire_core::hive::get_hive_location;
31
+
use wire_core::hive::node::ApplyObjective;
32
+
use wire_core::hive::node::Objective;
33
+
use wire_core::hive::node::should_apply_locally;
34
+
35
+
#[macro_use]
36
+
extern crate enum_display_derive;
37
+
38
+
mod apply;
39
+
mod cli;
40
+
mod sigint;
41
+
mod tracing_setup;
42
+
43
+
#[cfg(feature = "dhat-heap")]
44
+
#[global_allocator]
45
+
static ALLOC: dhat::Alloc = dhat::Alloc;
46
+
47
+
#[tokio::main]
48
+
async fn main() -> Result<()> {
49
+
#[cfg(feature = "dhat-heap")]
50
+
let _profiler = dhat::Profiler::new_heap();
51
+
CompleteEnv::with_factory(Cli::command).complete();
52
+
53
+
let args = Cli::parse();
54
+
55
+
let modifiers = args.to_subcommand_modifiers();
56
+
// disable progress when running inspect mode.
57
+
setup_logging(
58
+
&args.verbose,
59
+
!matches!(args.command, cli::Commands::Inspect { .. }) && !&args.no_progress,
60
+
);
61
+
62
+
#[cfg(debug_assertions)]
63
+
if args.markdown_help {
64
+
clap_markdown::print_help_markdown::<Cli>();
65
+
return Ok(());
66
+
}
67
+
68
+
if !check_nix_available() {
69
+
miette::bail!("Nix is not available on this system.");
70
+
}
71
+
72
+
let signals = Signals::new([SIGINT]).into_diagnostic()?;
73
+
let signals_handle = signals.handle();
74
+
let should_shutdown = Arc::new(AtomicBool::new(false));
75
+
let signals_task = tokio::spawn(handle_signals(signals, should_shutdown.clone()));
76
+
77
+
let location = get_hive_location(args.path, modifiers).await?;
78
+
let cache = InspectionCache::new().await;
79
+
80
+
match args.command {
81
+
cli::Commands::Apply(apply_args) => {
82
+
let mut hive = Hive::new_from_path(&location, cache.clone(), modifiers).await?;
83
+
let goal: wire_core::hive::node::Goal = apply_args.goal.clone().try_into().unwrap();
84
+
85
+
// Respect user's --always-build-local arg
86
+
hive.force_always_local(apply_args.always_build_local)?;
87
+
88
+
apply::apply(
89
+
&mut hive,
90
+
should_shutdown,
91
+
location,
92
+
apply_args.common,
93
+
Partitions::default(),
94
+
|name, node| {
95
+
Objective::Apply(ApplyObjective {
96
+
goal,
97
+
no_keys: apply_args.no_keys,
98
+
reboot: apply_args.reboot,
99
+
substitute_on_destination: apply_args.substitute_on_destination,
100
+
should_apply_locally: should_apply_locally(
101
+
node.allow_local_deployment,
102
+
&name.0,
103
+
),
104
+
handle_unreachable: apply_args.handle_unreachable.clone().into(),
105
+
})
106
+
},
107
+
modifiers,
108
+
)
109
+
.await?;
110
+
}
111
+
cli::Commands::Build(build_args) => {
112
+
let mut hive = Hive::new_from_path(&location, cache.clone(), modifiers).await?;
113
+
114
+
apply::apply(
115
+
&mut hive,
116
+
should_shutdown,
117
+
location,
118
+
build_args.common,
119
+
build_args.partition.unwrap_or_default(),
120
+
|_name, _node| Objective::BuildLocally,
121
+
modifiers,
122
+
)
123
+
.await?;
124
+
}
125
+
cli::Commands::Inspect { json, selection } => println!("{}", {
126
+
match selection {
127
+
cli::Inspection::Full => {
128
+
let hive = Hive::new_from_path(&location, cache.clone(), modifiers).await?;
129
+
if json {
130
+
serde_json::to_string(&hive).into_diagnostic()?
131
+
} else {
132
+
warn!("use --json to output something scripting suitable");
133
+
format!("{hive}")
134
+
}
135
+
}
136
+
cli::Inspection::Names => {
137
+
serde_json::to_string(&get_hive_node_names(&location, modifiers).await?)
138
+
.into_diagnostic()?
139
+
}
140
+
}
141
+
}),
142
+
}
143
+
144
+
if let Some(cache) = cache {
145
+
cache.gc().await.into_diagnostic()?;
146
+
}
147
+
148
+
signals_handle.close();
149
+
signals_task.await.into_diagnostic()?;
150
+
151
+
Ok(())
152
+
}
153
+
154
+
fn check_nix_available() -> bool {
155
+
match Command::new("nix")
156
+
.stdout(std::process::Stdio::null())
157
+
.stderr(std::process::Stdio::null())
158
+
.spawn()
159
+
{
160
+
Ok(_) => true,
161
+
Err(e) => {
162
+
if let std::io::ErrorKind::NotFound = e.kind() {
163
+
false
164
+
} else {
165
+
error!(
166
+
"Something weird happened checking for nix availability, {}",
167
+
e
168
+
);
169
+
false
170
+
}
171
+
}
172
+
}
173
+
}
+21
crates/cli/src/sigint.rs
+21
crates/cli/src/sigint.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::sync::{Arc, atomic::AtomicBool};
5
+
6
+
use signal_hook::consts::SIGINT;
7
+
use signal_hook_tokio::Signals;
8
+
9
+
use futures::stream::StreamExt;
10
+
use tracing::info;
11
+
12
+
pub(crate) async fn handle_signals(mut signals: Signals, should_shutdown: Arc<AtomicBool>) {
13
+
while let Some(signal) = signals.next().await {
14
+
if let SIGINT = signal
15
+
&& !should_shutdown.load(std::sync::atomic::Ordering::Relaxed)
16
+
{
17
+
info!("Received SIGINT, attempting to shut down executor tasks.");
18
+
should_shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
19
+
}
20
+
}
21
+
}
+284
crates/cli/src/tracing_setup.rs
+284
crates/cli/src/tracing_setup.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::{
5
+
collections::VecDeque,
6
+
io::{self, Stderr, Write, stderr},
7
+
time::Duration,
8
+
};
9
+
10
+
use clap_verbosity_flag::{LogLevel, Verbosity};
11
+
use owo_colors::{OwoColorize, Stream, Style};
12
+
use tracing::{Level, Subscriber};
13
+
use tracing_log::AsTrace;
14
+
use tracing_subscriber::{
15
+
Layer,
16
+
field::{RecordFields, VisitFmt},
17
+
fmt::{
18
+
FormatEvent, FormatFields, FormattedFields,
19
+
format::{self, DefaultFields, DefaultVisitor, Format, Full},
20
+
},
21
+
layer::{Context, SubscriberExt},
22
+
registry::LookupSpan,
23
+
util::SubscriberInitExt,
24
+
};
25
+
use wire_core::{STDIN_CLOBBER_LOCK, status::STATUS};
26
+
27
+
/// The non-clobbering writer ensures that log lines are held while interactive
28
+
/// prompts are shown to the user. If logs where shown, they would "clobber" the
29
+
/// sudo / ssh prompt.
30
+
///
31
+
/// Additionally, the `STDIN_CLOBBER_LOCK` is used to ensure that no two
32
+
/// interactive prompts are shown at the same time.
33
+
struct NonClobberingWriter {
34
+
queue: VecDeque<Vec<u8>>,
35
+
stderr: Stderr,
36
+
}
37
+
38
+
impl NonClobberingWriter {
39
+
fn new() -> Self {
40
+
NonClobberingWriter {
41
+
queue: VecDeque::with_capacity(100),
42
+
stderr: stderr(),
43
+
}
44
+
}
45
+
46
+
/// expects the caller to write the status line
47
+
fn dump_previous(&mut self) -> Result<(), io::Error> {
48
+
STATUS.lock().clear(&mut self.stderr);
49
+
50
+
for buf in self.queue.iter().rev() {
51
+
self.stderr.write(buf).map(|_| ())?;
52
+
}
53
+
54
+
Ok(())
55
+
}
56
+
}
57
+
58
+
impl Write for NonClobberingWriter {
59
+
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
60
+
if let 1.. = STDIN_CLOBBER_LOCK.available_permits() {
61
+
self.dump_previous().map(|()| 0)?;
62
+
63
+
STATUS.lock().write_above_status(buf, &mut self.stderr)
64
+
} else {
65
+
self.queue.push_front(buf.to_vec());
66
+
67
+
Ok(buf.len())
68
+
}
69
+
}
70
+
71
+
fn flush(&mut self) -> std::io::Result<()> {
72
+
self.stderr.flush()
73
+
}
74
+
}
75
+
76
+
/// Handles event formatting, which falls back to the default formatter
77
+
/// passed.
78
+
struct WireEventFormat(Format<Full, ()>);
79
+
/// Formats the node's name with `WireFieldVisitor`
80
+
struct WireFieldFormat;
81
+
struct WireFieldVisitor<'a>(DefaultVisitor<'a>);
82
+
/// `WireLayer` injects `WireFieldFormat` as an extension on the event
83
+
struct WireLayer;
84
+
85
+
impl<'a> WireFieldVisitor<'a> {
86
+
fn new(writer: format::Writer<'a>, is_empty: bool) -> Self {
87
+
Self(DefaultVisitor::new(writer, is_empty))
88
+
}
89
+
}
90
+
91
+
impl<'writer> FormatFields<'writer> for WireFieldFormat {
92
+
fn format_fields<R: RecordFields>(
93
+
&self,
94
+
writer: format::Writer<'writer>,
95
+
fields: R,
96
+
) -> std::fmt::Result {
97
+
let mut v = WireFieldVisitor::new(writer, true);
98
+
fields.record(&mut v);
99
+
Ok(())
100
+
}
101
+
}
102
+
103
+
impl tracing::field::Visit for WireFieldVisitor<'_> {
104
+
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
105
+
if field.name() == "node" {
106
+
let _ = write!(
107
+
self.0.writer(),
108
+
"{:?}",
109
+
value.if_supports_color(Stream::Stderr, |text| text.bold())
110
+
);
111
+
}
112
+
}
113
+
}
114
+
115
+
const fn get_style(level: Level) -> Style {
116
+
let mut style = Style::new();
117
+
118
+
style = match level {
119
+
Level::TRACE => style.purple(),
120
+
Level::DEBUG => style.blue(),
121
+
Level::INFO => style.green(),
122
+
Level::WARN => style.yellow(),
123
+
Level::ERROR => style.red(),
124
+
};
125
+
126
+
style
127
+
}
128
+
129
+
const fn fmt_level(level: Level) -> &'static str {
130
+
match level {
131
+
Level::TRACE => "TRACE",
132
+
Level::DEBUG => "DEBUG",
133
+
Level::INFO => " INFO",
134
+
Level::WARN => " WARN",
135
+
Level::ERROR => "ERROR",
136
+
}
137
+
}
138
+
139
+
impl<S, N> FormatEvent<S, N> for WireEventFormat
140
+
where
141
+
S: Subscriber + for<'a> LookupSpan<'a>,
142
+
N: for<'a> FormatFields<'a> + 'static,
143
+
{
144
+
fn format_event(
145
+
&self,
146
+
ctx: &tracing_subscriber::fmt::FmtContext<'_, S, N>,
147
+
mut writer: tracing_subscriber::fmt::format::Writer<'_>,
148
+
event: &tracing::Event<'_>,
149
+
) -> std::fmt::Result {
150
+
let metadata = event.metadata();
151
+
152
+
// skip events without an "event_scope"
153
+
let Some(scope) = ctx.event_scope() else {
154
+
return self.0.format_event(ctx, writer, event);
155
+
};
156
+
157
+
// skip spans without a parent
158
+
let Some(parent) = scope.last() else {
159
+
return self.0.format_event(ctx, writer, event);
160
+
};
161
+
162
+
// skip spans that dont refer to the goal step executor
163
+
if parent.name() != "execute" {
164
+
return self.0.format_event(ctx, writer, event);
165
+
}
166
+
167
+
// skip spans that dont refer to a specific node being executed
168
+
if parent.fields().field("node").is_none() {
169
+
return self.0.format_event(ctx, writer, event);
170
+
}
171
+
172
+
let style = get_style(*metadata.level());
173
+
174
+
// write the log level with colour
175
+
write!(
176
+
writer,
177
+
"{} ",
178
+
fmt_level(*metadata.level()).if_supports_color(Stream::Stderr, |x| { x.style(style) })
179
+
)?;
180
+
181
+
// extract the formatted node name into a string
182
+
let parent_ext = parent.extensions();
183
+
let node_name = &parent_ext
184
+
.get::<FormattedFields<WireFieldFormat>>()
185
+
.unwrap();
186
+
187
+
write!(writer, "{node_name}")?;
188
+
189
+
// write the step name
190
+
if let Some(step) = ctx.event_scope().unwrap().from_root().nth(1) {
191
+
write!(writer, " {}", step.name().italic())?;
192
+
}
193
+
194
+
write!(writer, " | ")?;
195
+
196
+
// write the default fields, including the actual message and other data
197
+
let mut fields = FormattedFields::<DefaultFields>::new(String::new());
198
+
199
+
ctx.format_fields(fields.as_writer(), event)?;
200
+
201
+
write!(writer, "{fields}")?;
202
+
writeln!(writer)?;
203
+
204
+
Ok(())
205
+
}
206
+
}
207
+
208
+
impl<S> Layer<S> for WireLayer
209
+
where
210
+
S: Subscriber + for<'a> LookupSpan<'a>,
211
+
{
212
+
fn on_new_span(
213
+
&self,
214
+
attrs: &tracing::span::Attributes<'_>,
215
+
id: &tracing::span::Id,
216
+
ctx: Context<'_, S>,
217
+
) {
218
+
let span = ctx.span(id).unwrap();
219
+
220
+
if span.extensions().get::<WireFieldFormat>().is_some() {
221
+
return;
222
+
}
223
+
224
+
let mut fields = FormattedFields::<WireFieldFormat>::new(String::new());
225
+
if WireFieldFormat
226
+
.format_fields(fields.as_writer(), attrs)
227
+
.is_ok()
228
+
{
229
+
span.extensions_mut().insert(fields);
230
+
}
231
+
}
232
+
}
233
+
234
+
async fn status_tick_worker() {
235
+
let mut interval = tokio::time::interval(Duration::from_secs(1));
236
+
let mut stderr = stderr();
237
+
238
+
loop {
239
+
interval.tick().await;
240
+
241
+
if STDIN_CLOBBER_LOCK.available_permits() < 1 {
242
+
continue;
243
+
}
244
+
245
+
let mut status = STATUS.lock();
246
+
247
+
status.clear(&mut stderr);
248
+
status.write_status(&mut stderr);
249
+
}
250
+
}
251
+
252
+
/// Set up logging for the application
253
+
/// Uses `WireFieldFormat` if -v was never passed
254
+
pub fn setup_logging<L: LogLevel>(verbosity: &Verbosity<L>, show_progress: bool) {
255
+
let filter = verbosity.log_level_filter().as_trace();
256
+
let registry = tracing_subscriber::registry();
257
+
258
+
STATUS.lock().show_progress(show_progress);
259
+
260
+
// spawn worker to tick the status bar
261
+
if show_progress {
262
+
tokio::spawn(status_tick_worker());
263
+
}
264
+
265
+
if verbosity.is_present() {
266
+
let layer = tracing_subscriber::fmt::layer()
267
+
.without_time()
268
+
.with_target(false)
269
+
.with_writer(NonClobberingWriter::new)
270
+
.with_filter(filter);
271
+
272
+
registry.with(layer).init();
273
+
return;
274
+
}
275
+
276
+
let event_formatter = WireEventFormat(format::format().without_time().with_target(false));
277
+
278
+
let layer = tracing_subscriber::fmt::layer()
279
+
.event_format(event_formatter)
280
+
.with_writer(NonClobberingWriter::new)
281
+
.with_filter(filter);
282
+
283
+
registry.with(layer).with(WireLayer).init();
284
+
}
+51
crates/core/Cargo.toml
+51
crates/core/Cargo.toml
···
1
+
[package]
2
+
name = "wire-core"
3
+
version.workspace = true
4
+
edition.workspace = true
5
+
6
+
[lints]
7
+
workspace = true
8
+
9
+
[features]
10
+
no_web_tests = []
11
+
12
+
[dependencies]
13
+
tokio = { workspace = true }
14
+
serde = { workspace = true }
15
+
serde_json = { workspace = true }
16
+
tracing = { workspace = true }
17
+
im = { workspace = true }
18
+
thiserror = "2.0.17"
19
+
derive_more = { version = "2.0.1", features = ["display"] }
20
+
wire-key-agent = { path = "../key_agent" }
21
+
futures = "0.3.31"
22
+
prost = { workspace = true }
23
+
gethostname = "1.1.0"
24
+
nix.workspace = true
25
+
miette = { workspace = true }
26
+
rand = "0.9.2"
27
+
tokio-util = { workspace = true }
28
+
portable-pty = "0.9.0"
29
+
anyhow.workspace = true
30
+
itertools = "0.14.0"
31
+
enum_dispatch = "0.3.13"
32
+
sha2 = { workspace = true }
33
+
base64 = { workspace = true }
34
+
nix-compat = { workspace = true }
35
+
strip-ansi-escapes = "0.2.1"
36
+
aho-corasick = "1.1.4"
37
+
num_enum = "0.7.5"
38
+
gjson = "0.8.1"
39
+
owo-colors = { workspace = true }
40
+
termion = "4.0.6"
41
+
sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
42
+
zstd = "0.13.3"
43
+
44
+
[dev-dependencies]
45
+
tempdir = "0.3"
46
+
47
+
[build-dependencies]
48
+
miette = { workspace = true }
49
+
syn = "2.0.109"
50
+
proc-macro2 = "1.0.103"
51
+
itertools = "0.14.0"
+206
crates/core/build.rs
+206
crates/core/build.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use miette::{Context, IntoDiagnostic as _, Result, miette};
5
+
use std::fmt::Write;
6
+
use std::{
7
+
env,
8
+
fmt::{self, Display, Formatter},
9
+
fs::{self},
10
+
path::Path,
11
+
};
12
+
13
+
use itertools::Itertools;
14
+
use proc_macro2::TokenTree;
15
+
use syn::{Expr, Item, ItemEnum, Lit, Meta, MetaList, MetaNameValue, parse_file};
16
+
17
+
macro_rules! p {
18
+
($($tokens: tt)*) => {
19
+
println!("cargo::warning={}", format!($($tokens)*))
20
+
}
21
+
}
22
+
23
+
#[derive(Debug)]
24
+
struct DerivedError {
25
+
code: Option<String>,
26
+
help: Option<String>,
27
+
message: Option<String>,
28
+
doc_string: String,
29
+
}
30
+
31
+
impl Display for DerivedError {
32
+
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
33
+
write!(
34
+
f,
35
+
"## `{code}` {{#{code}}}
36
+
37
+
{doc}
38
+
{message}
39
+
{help}",
40
+
doc = self.doc_string,
41
+
code = self.code.as_ref().unwrap(),
42
+
help = match &self.help {
43
+
Some(help) => format!(
44
+
"
45
+
::: tip HELP
46
+
{help}
47
+
:::"
48
+
),
49
+
None => String::new(),
50
+
},
51
+
message = match &self.message {
52
+
Some(message) => format!(
53
+
"
54
+
```txt [message]
55
+
{message}
56
+
```"
57
+
),
58
+
None => String::new(),
59
+
}
60
+
)
61
+
}
62
+
}
63
+
64
+
impl DerivedError {
65
+
fn get_error(&mut self, list: &MetaList) -> Result<(), miette::Error> {
66
+
if list.path.segments.last().unwrap().ident != "error" {
67
+
return Err(miette!("Not an error"));
68
+
}
69
+
70
+
self.message = Some(
71
+
list.tokens
72
+
.clone()
73
+
.into_iter()
74
+
.filter(|tok| matches!(tok, TokenTree::Literal(tok) if tok.to_string().starts_with('"')))
75
+
.map(|tok| tok.to_string())
76
+
.join(""),
77
+
);
78
+
79
+
Err(miette!("No error msg found"))
80
+
}
81
+
82
+
fn update_diagnostic(&mut self, list: &MetaList) -> Result<(), miette::Error> {
83
+
if list.path.segments.last().unwrap().ident != "diagnostic" {
84
+
return Err(miette!("Not a diagnostic"));
85
+
}
86
+
87
+
let vec: Vec<_> = list.tokens.clone().into_iter().collect();
88
+
89
+
// Find `diagnostic(code(x::y::z))`
90
+
let code: Option<String> = if let Some((_, TokenTree::Group(group))) =
91
+
vec.iter().tuple_windows().find(|(ident, group)| {
92
+
matches!(ident, TokenTree::Ident(ident) if ident == "code")
93
+
&& matches!(group, TokenTree::Group(..))
94
+
}) {
95
+
Some(group.stream().to_string().replace(' ', ""))
96
+
} else {
97
+
None
98
+
};
99
+
100
+
// Find `diagnostic(help("hi"))`
101
+
let help: Option<String> = if let Some((_, TokenTree::Group(group))) =
102
+
vec.iter().tuple_windows().find(|(ident, group)| {
103
+
matches!(ident, TokenTree::Ident(ident) if ident == "help")
104
+
&& matches!(group, TokenTree::Group(..))
105
+
}) {
106
+
Some(group.stream().to_string())
107
+
} else {
108
+
None
109
+
};
110
+
111
+
if let Some(code) = code {
112
+
self.code = Some(code);
113
+
self.help = help;
114
+
return Ok(());
115
+
}
116
+
117
+
Err(miette!("Had no code."))
118
+
}
119
+
120
+
fn update_from_list(&mut self, list: &MetaList) {
121
+
let _ = self.get_error(list);
122
+
let _ = self.update_diagnostic(list);
123
+
}
124
+
125
+
fn update_from_namevalue(&mut self, list: MetaNameValue) -> Result<(), miette::Error> {
126
+
if list.path.segments.last().unwrap().ident != "doc" {
127
+
return Err(miette!("Not a doc string"));
128
+
}
129
+
130
+
if let Expr::Lit(lit) = list.value
131
+
&& let Lit::Str(str) = lit.lit
132
+
{
133
+
let _ = write!(self.doc_string, "{}\n\n", &str.value()[1..]);
134
+
}
135
+
136
+
Ok(())
137
+
}
138
+
}
139
+
140
+
fn main() -> Result<()> {
141
+
println!("cargo:rerun-if-changed=src/errors.rs");
142
+
143
+
let manifest_dir = env::var("CARGO_MANIFEST_DIR").into_diagnostic()?;
144
+
let Ok(md_out_dir) = env::var("DIAGNOSTICS_MD_OUTPUT") else {
145
+
return Ok(());
146
+
};
147
+
148
+
let src_path = Path::new(&manifest_dir).join("src/errors.rs");
149
+
let src = fs::read_to_string(&src_path)
150
+
.into_diagnostic()
151
+
.wrap_err("reading errors.rs")?;
152
+
153
+
let syntax_tree = parse_file(&src)
154
+
.into_diagnostic()
155
+
.wrap_err("parsing errors.rs")?;
156
+
let mut entries: Vec<DerivedError> = Vec::new();
157
+
158
+
for item in &syntax_tree.items {
159
+
if let Item::Enum(ItemEnum { variants, .. }) = item {
160
+
for variant in variants {
161
+
let mut entry = DerivedError {
162
+
code: None,
163
+
help: None,
164
+
message: None,
165
+
doc_string: String::new(),
166
+
};
167
+
168
+
for attribute in variant.attrs.clone() {
169
+
match attribute.meta {
170
+
Meta::List(list) => {
171
+
entry.update_from_list(&list);
172
+
}
173
+
Meta::NameValue(nv) => {
174
+
let _ = entry.update_from_namevalue(nv);
175
+
}
176
+
Meta::Path(_) => {}
177
+
}
178
+
}
179
+
180
+
if entry.code.is_some() {
181
+
entries.push(entry);
182
+
}
183
+
}
184
+
}
185
+
}
186
+
187
+
fs::create_dir_all(Path::new(&md_out_dir))
188
+
.into_diagnostic()
189
+
.wrap_err("creating target directory")?;
190
+
fs::write(
191
+
Path::new(&md_out_dir).join("DIAGNOSTICS.md"),
192
+
entries
193
+
.iter()
194
+
.map(std::string::ToString::to_string)
195
+
.join("\n\n"),
196
+
)
197
+
.into_diagnostic()
198
+
.wrap_err("writing DIAGNOSTICS.md")?;
199
+
200
+
p!(
201
+
"wrote to {:?}",
202
+
Path::new(&md_out_dir).join("DIAGNOSTICS.md")
203
+
);
204
+
205
+
Ok(())
206
+
}
+13
crates/core/src/cache/migrations/20251124234730_init.sql
+13
crates/core/src/cache/migrations/20251124234730_init.sql
···
1
+
create table hive_inspection (
2
+
id integer primary key autoincrement,
3
+
json_value text not null unique
4
+
) strict;
5
+
6
+
create table cached_inspection (
7
+
store_path text,
8
+
hash text,
9
+
10
+
inspection_id integer references hive_inspection(id) not null,
11
+
12
+
primary key (store_path, hash)
13
+
) strict;
+16
crates/core/src/cache/migrations/20251126222409_blobs.sql
+16
crates/core/src/cache/migrations/20251126222409_blobs.sql
···
1
+
create table inspection_blobs (
2
+
id integer primary key autoincrement,
3
+
json_value blob not null unique,
4
+
schema_version integer not null
5
+
) strict;
6
+
7
+
create table inspection_cache (
8
+
store_path text,
9
+
hash text,
10
+
blob_id integer references inspection_blobs (id) not null,
11
+
primary key (store_path, hash)
12
+
) strict;
13
+
14
+
drop table cached_inspection;
15
+
16
+
drop table hive_inspection;
+237
crates/core/src/cache/mod.rs
+237
crates/core/src/cache/mod.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::{
5
+
env,
6
+
path::{Path, PathBuf},
7
+
};
8
+
9
+
use sqlx::{
10
+
Pool, Sqlite,
11
+
migrate::Migrator,
12
+
sqlite::{SqliteConnectOptions, SqlitePoolOptions},
13
+
};
14
+
use tokio::fs::create_dir_all;
15
+
use tracing::{debug, error, trace};
16
+
17
+
use crate::hive::{FlakePrefetch, Hive};
18
+
19
+
#[derive(Clone)]
20
+
pub struct InspectionCache {
21
+
pool: Pool<Sqlite>,
22
+
}
23
+
24
+
static MIGRATOR: Migrator = sqlx::migrate!("src/cache/migrations");
25
+
26
+
async fn get_cache_directory() -> Option<PathBuf> {
27
+
let home = PathBuf::from(
28
+
env::var("HOME")
29
+
.inspect_err(|_| error!("HOME env var not found"))
30
+
.ok()?,
31
+
);
32
+
33
+
trace!(home = ?home);
34
+
35
+
let cache_home = env::var("XDG_CACHE_HOME")
36
+
.inspect_err(|_| debug!("XDG_CACHE_HOME not found"))
37
+
.ok()
38
+
.map(PathBuf::from)
39
+
.unwrap_or(home.join(".cache"));
40
+
41
+
let cache_directory = cache_home.join("wire");
42
+
43
+
trace!(cache_directory = ?cache_directory);
44
+
45
+
let _ = create_dir_all(&cache_directory).await;
46
+
47
+
Some(cache_directory)
48
+
}
49
+
50
+
impl InspectionCache {
51
+
pub async fn new() -> Option<Self> {
52
+
let cache_path = get_cache_directory().await?.join("inspect.db");
53
+
debug!(cache_path = ?cache_path);
54
+
55
+
let pool = SqlitePoolOptions::new()
56
+
.max_connections(1)
57
+
.connect_with(
58
+
SqliteConnectOptions::new()
59
+
.filename(cache_path)
60
+
.create_if_missing(true),
61
+
)
62
+
.await
63
+
.inspect_err(|x| error!("failed to open cache db: {x}"))
64
+
.ok()?;
65
+
66
+
MIGRATOR
67
+
.run(&pool)
68
+
.await
69
+
.inspect_err(|err| error!("failed to run cache migrations: {err:?}"))
70
+
.ok()?;
71
+
72
+
Some(Self { pool })
73
+
}
74
+
75
+
fn cache_invalid(store_path: &String) -> bool {
76
+
let path = Path::new(store_path);
77
+
78
+
// possible TOCTOU
79
+
!path.exists()
80
+
}
81
+
82
+
pub async fn get_hive(&self, prefetch: &FlakePrefetch) -> Option<Hive> {
83
+
struct Query {
84
+
json_value: Vec<u8>,
85
+
store_path: String,
86
+
}
87
+
88
+
let cached_blob = sqlx::query_as!(
89
+
Query,
90
+
"
91
+
select
92
+
inspection_blobs.json_value,
93
+
inspection_cache.store_path
94
+
from
95
+
inspection_blobs
96
+
join inspection_cache on inspection_cache.blob_id = inspection_blobs.id
97
+
where
98
+
inspection_cache.store_path = $1
99
+
and inspection_cache.hash = $2
100
+
and inspection_blobs.schema_version = $3
101
+
limit
102
+
1
103
+
",
104
+
prefetch.store_path,
105
+
prefetch.hash,
106
+
Hive::SCHEMA_VERSION
107
+
)
108
+
.fetch_optional(&self.pool)
109
+
.await
110
+
.inspect_err(|x| error!("failed to fetch cached hive: {x}"))
111
+
.ok()??;
112
+
113
+
// the cached path may of been garbage collected, discard it
114
+
// it is quite hard to replicate this bug but its occurred to me
115
+
// atleast once
116
+
if Self::cache_invalid(&cached_blob.store_path) {
117
+
trace!("discarding cache that does not exist in the nix store");
118
+
return None;
119
+
}
120
+
121
+
trace!(
122
+
"read {} bytes of zstd data from cache",
123
+
cached_blob.json_value.len()
124
+
);
125
+
126
+
let json_string = zstd::decode_all(cached_blob.json_value.as_slice())
127
+
.inspect_err(|err| error!("failed to decode cached zstd data: {err}"))
128
+
.ok()?;
129
+
130
+
trace!(
131
+
"inflated {} > {} in decoding",
132
+
cached_blob.json_value.len(),
133
+
json_string.len()
134
+
);
135
+
136
+
serde_json::from_slice(&json_string)
137
+
.inspect_err(|err| {
138
+
error!("could not use cached evaluation: {err}");
139
+
})
140
+
.ok()
141
+
}
142
+
143
+
pub async fn store_hive(&self, prefetch: &FlakePrefetch, json_value: &String) {
144
+
let Ok(json_value) = zstd::encode_all(json_value.as_bytes(), 0)
145
+
.inspect_err(|err| error!("failed to encode data w/ zstd: {err}"))
146
+
else {
147
+
return;
148
+
};
149
+
150
+
let hive_inspection = sqlx::query_scalar!(
151
+
"
152
+
insert into inspection_blobs (json_value, schema_version)
153
+
values ($1, $2)
154
+
on conflict(json_value)
155
+
do update set json_value = excluded.json_value
156
+
returning inspection_blobs.id
157
+
",
158
+
json_value,
159
+
Hive::SCHEMA_VERSION
160
+
)
161
+
.fetch_one(&self.pool)
162
+
.await
163
+
.inspect_err(|x| error!("could not insert hive_inspection: {x}"));
164
+
165
+
let Ok(blob_id) = hive_inspection else {
166
+
return;
167
+
};
168
+
169
+
let cached_inspection = sqlx::query!(
170
+
"
171
+
insert into
172
+
inspection_cache (store_path, hash, blob_id)
173
+
values
174
+
($1, $2, $3)
175
+
",
176
+
prefetch.store_path,
177
+
prefetch.hash,
178
+
blob_id
179
+
)
180
+
.execute(&self.pool)
181
+
.await;
182
+
183
+
if let Err(err) = cached_inspection {
184
+
error!("could not insert cached_inspection: {err}");
185
+
}
186
+
}
187
+
188
+
pub async fn gc(&self) -> Result<(), sqlx::Error> {
189
+
// keep newest 30 AND
190
+
// delete caches that refer to a blob w/ wrong schema
191
+
sqlx::query!(
192
+
"delete from inspection_cache
193
+
where
194
+
blob_id in (
195
+
select
196
+
id
197
+
from
198
+
inspection_blobs
199
+
where
200
+
schema_version != $1
201
+
)
202
+
or ROWID in (
203
+
select
204
+
ROWID
205
+
from
206
+
inspection_cache
207
+
order by
208
+
ROWID desc
209
+
limit
210
+
-1
211
+
offset
212
+
30
213
+
)",
214
+
Hive::SCHEMA_VERSION
215
+
)
216
+
.execute(&self.pool)
217
+
.await?;
218
+
219
+
// delete orphaned blobs
220
+
sqlx::query!(
221
+
"delete from inspection_blobs
222
+
where
223
+
not exists (
224
+
select
225
+
1
226
+
from
227
+
inspection_cache
228
+
where
229
+
inspection_cache.blob_id = inspection_blobs.id
230
+
)"
231
+
)
232
+
.execute(&self.pool)
233
+
.await?;
234
+
235
+
Ok(())
236
+
}
237
+
}
+74
crates/core/src/commands/builder.rs
+74
crates/core/src/commands/builder.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt;
5
+
6
+
pub(crate) struct CommandStringBuilder {
7
+
command: String,
8
+
}
9
+
10
+
impl CommandStringBuilder {
11
+
pub(crate) fn nix() -> Self {
12
+
Self {
13
+
command: "nix".to_string(),
14
+
}
15
+
}
16
+
17
+
pub(crate) fn new<S: AsRef<str>>(s: S) -> Self {
18
+
Self {
19
+
command: s.as_ref().trim().to_string(),
20
+
}
21
+
}
22
+
23
+
pub(crate) fn arg<S: AsRef<str>>(&mut self, argument: S) {
24
+
let argument = argument.as_ref().trim();
25
+
self.command.push(' ');
26
+
self.command.push_str(argument);
27
+
}
28
+
29
+
pub(crate) fn opt_arg<S: AsRef<str>>(&mut self, opt: bool, argument: S) {
30
+
if !opt {
31
+
return;
32
+
}
33
+
34
+
self.arg(argument);
35
+
}
36
+
37
+
pub(crate) fn args<S: AsRef<str>>(&mut self, arguments: &[S]) {
38
+
for arg in arguments {
39
+
self.arg(arg);
40
+
}
41
+
}
42
+
}
43
+
44
+
impl fmt::Display for CommandStringBuilder {
45
+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
46
+
write!(f, "{}", self.command)
47
+
}
48
+
}
49
+
50
+
impl AsRef<str> for CommandStringBuilder {
51
+
fn as_ref(&self) -> &str {
52
+
&self.command
53
+
}
54
+
}
55
+
56
+
#[cfg(test)]
57
+
mod tests {
58
+
use crate::commands::builder::CommandStringBuilder;
59
+
60
+
#[test]
61
+
fn command_builder() {
62
+
let mut builder = CommandStringBuilder::new("a");
63
+
builder.arg(" b ");
64
+
builder.args(&[" c ", "d", "e"]);
65
+
builder.opt_arg(false, "f");
66
+
builder.opt_arg(true, "g");
67
+
68
+
assert_eq!(
69
+
builder.to_string(),
70
+
std::convert::AsRef::<str>::as_ref(&builder)
71
+
);
72
+
assert_eq!(builder.to_string(), "a b c d e g");
73
+
}
74
+
}
+177
crates/core/src/commands/common.rs
+177
crates/core/src/commands/common.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::collections::HashMap;
5
+
6
+
use tracing::instrument;
7
+
8
+
use crate::{
9
+
EvalGoal, SubCommandModifiers,
10
+
commands::{
11
+
CommandArguments, Either, WireCommandChip, builder::CommandStringBuilder, run_command,
12
+
run_command_with_env,
13
+
},
14
+
errors::{CommandError, HiveInitialisationError, HiveLibError},
15
+
hive::{
16
+
HiveLocation,
17
+
node::{Context, Objective, Push},
18
+
},
19
+
};
20
+
21
+
fn get_common_copy_path_help(error: &CommandError) -> Option<String> {
22
+
if let CommandError::CommandFailed { logs, .. } = error
23
+
&& (logs.contains("error: unexpected end-of-file"))
24
+
{
25
+
Some("wire requires the deploying user or wire binary cache is trusted on the remote server. if you're attempting to make that change, skip keys with --no-keys. please read https://wire.althaea.zone/guides/keys for more information".to_string())
26
+
} else {
27
+
None
28
+
}
29
+
}
30
+
31
+
pub async fn push(context: &Context<'_>, push: Push<'_>) -> Result<(), HiveLibError> {
32
+
let mut command_string = CommandStringBuilder::nix();
33
+
34
+
command_string.args(&["--extra-experimental-features", "nix-command", "copy"]);
35
+
if let Objective::Apply(apply_objective) = context.objective {
36
+
command_string.opt_arg(
37
+
apply_objective.substitute_on_destination,
38
+
"--substitute-on-destination",
39
+
);
40
+
}
41
+
command_string.arg("--to");
42
+
command_string.args(&[
43
+
format!(
44
+
"ssh://{user}@{host}",
45
+
user = context.node.target.user,
46
+
host = context.node.target.get_preferred_host()?,
47
+
),
48
+
match push {
49
+
Push::Derivation(drv) => format!("{drv} --derivation"),
50
+
Push::Path(path) => path.clone(),
51
+
},
52
+
]);
53
+
54
+
let child = run_command_with_env(
55
+
&CommandArguments::new(command_string, context.modifiers)
56
+
.mode(crate::commands::ChildOutputMode::Nix),
57
+
HashMap::from([(
58
+
"NIX_SSHOPTS".into(),
59
+
context
60
+
.node
61
+
.target
62
+
.create_ssh_opts(context.modifiers, false)?,
63
+
)]),
64
+
)
65
+
.await?;
66
+
67
+
let status = child.wait_till_success().await;
68
+
69
+
let help = if let Err(ref error) = status {
70
+
get_common_copy_path_help(error).map(Box::new)
71
+
} else {
72
+
None
73
+
};
74
+
75
+
status.map_err(|error| HiveLibError::NixCopyError {
76
+
name: context.name.clone(),
77
+
path: push.to_string(),
78
+
error: Box::new(error),
79
+
help,
80
+
})?;
81
+
82
+
Ok(())
83
+
}
84
+
85
+
fn get_common_command_help(error: &CommandError) -> Option<String> {
86
+
if let CommandError::CommandFailed { logs, .. } = error
87
+
// marshmallow: your using this repo as a hive you idiot
88
+
&& (logs.contains("attribute 'inspect' missing")
89
+
// using a flake that does not provide `wire`
90
+
|| logs.contains("does not provide attribute 'packages.x86_64-linux.wire'")
91
+
// using a file called `hive.nix` that is not actually a hive
92
+
|| logs.contains("attribute 'inspect' in selection path"))
93
+
{
94
+
Some("Double check this `--path` or `--flake` is a wire hive. You may be pointing to the wrong directory.".to_string())
95
+
} else {
96
+
None
97
+
}
98
+
}
99
+
100
+
pub async fn get_hive_node_names(
101
+
location: &HiveLocation,
102
+
modifiers: SubCommandModifiers,
103
+
) -> Result<Vec<String>, HiveLibError> {
104
+
let output = evaluate_hive_attribute(location, &EvalGoal::Names, modifiers).await?;
105
+
serde_json::from_str(&output).map_err(|err| {
106
+
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParseEvaluateError(err))
107
+
})
108
+
}
109
+
110
+
/// Evaluates the hive in flakeref with regards to the given goal,
111
+
/// and returns stdout.
112
+
#[instrument(ret(level = tracing::Level::TRACE), skip_all)]
113
+
pub async fn evaluate_hive_attribute(
114
+
location: &HiveLocation,
115
+
goal: &EvalGoal<'_>,
116
+
modifiers: SubCommandModifiers,
117
+
) -> Result<String, HiveLibError> {
118
+
let attribute = match location {
119
+
HiveLocation::Flake { uri, .. } => {
120
+
format!(
121
+
"{uri}#wire --apply \"hive: {}\"",
122
+
match goal {
123
+
EvalGoal::Inspect => "hive.inspect".to_string(),
124
+
EvalGoal::Names => "hive.names".to_string(),
125
+
EvalGoal::GetTopLevel(node) => format!("hive.topLevels.{node}"),
126
+
}
127
+
)
128
+
}
129
+
HiveLocation::HiveNix(path) => {
130
+
format!(
131
+
"--file {} {}",
132
+
&path.to_string_lossy(),
133
+
match goal {
134
+
EvalGoal::Inspect => "inspect".to_string(),
135
+
EvalGoal::Names => "names".to_string(),
136
+
EvalGoal::GetTopLevel(node) => format!("topLevels.{node}"),
137
+
}
138
+
)
139
+
}
140
+
};
141
+
142
+
let mut command_string = CommandStringBuilder::nix();
143
+
command_string.args(&[
144
+
"--extra-experimental-features",
145
+
"nix-command",
146
+
"--extra-experimental-features",
147
+
"flakes",
148
+
"eval",
149
+
"--json",
150
+
]);
151
+
command_string.opt_arg(modifiers.show_trace, "--show-trace");
152
+
command_string.arg(&attribute);
153
+
154
+
let child = run_command(
155
+
&CommandArguments::new(command_string, modifiers)
156
+
.mode(crate::commands::ChildOutputMode::Nix),
157
+
)
158
+
.await?;
159
+
160
+
let status = child.wait_till_success().await;
161
+
162
+
let help = if let Err(ref error) = status {
163
+
get_common_command_help(error).map(Box::new)
164
+
} else {
165
+
None
166
+
};
167
+
168
+
status
169
+
.map_err(|source| HiveLibError::NixEvalError {
170
+
attribute,
171
+
source,
172
+
help,
173
+
})
174
+
.map(|x| match x {
175
+
Either::Left((_, stdout)) | Either::Right((_, stdout)) => stdout,
176
+
})
177
+
}
+240
crates/core/src/commands/mod.rs
+240
crates/core/src/commands/mod.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use crate::commands::pty::{InteractiveChildChip, interactive_command_with_env};
5
+
use std::{collections::HashMap, str::from_utf8, sync::LazyLock};
6
+
7
+
use aho_corasick::AhoCorasick;
8
+
use gjson::Value;
9
+
use itertools::Itertools;
10
+
use nix_compat::log::{AT_NIX_PREFIX, VerbosityLevel};
11
+
use num_enum::TryFromPrimitive;
12
+
use tracing::{debug, error, info, trace, warn};
13
+
14
+
use crate::{
15
+
SubCommandModifiers,
16
+
commands::noninteractive::{NonInteractiveChildChip, non_interactive_command_with_env},
17
+
errors::{CommandError, HiveLibError},
18
+
hive::node::{Node, Target},
19
+
};
20
+
21
+
pub(crate) mod builder;
22
+
pub mod common;
23
+
pub(crate) mod noninteractive;
24
+
pub(crate) mod pty;
25
+
26
+
#[derive(Copy, Clone, Debug)]
27
+
pub(crate) enum ChildOutputMode {
28
+
Nix,
29
+
Generic,
30
+
Interactive,
31
+
}
32
+
33
+
#[derive(Debug)]
34
+
pub enum Either<L, R> {
35
+
Left(L),
36
+
Right(R),
37
+
}
38
+
39
+
#[derive(Debug)]
40
+
pub(crate) struct CommandArguments<'t, S: AsRef<str>> {
41
+
modifiers: SubCommandModifiers,
42
+
target: Option<&'t Target>,
43
+
output_mode: ChildOutputMode,
44
+
command_string: S,
45
+
keep_stdin_open: bool,
46
+
privilege_escalation_command: Option<String>,
47
+
log_stdout: bool,
48
+
}
49
+
50
+
static AHO_CORASICK: LazyLock<AhoCorasick> = LazyLock::new(|| {
51
+
AhoCorasick::builder()
52
+
.ascii_case_insensitive(false)
53
+
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
54
+
.build([AT_NIX_PREFIX])
55
+
.unwrap()
56
+
});
57
+
58
+
impl<'a, S: AsRef<str>> CommandArguments<'a, S> {
59
+
pub(crate) const fn new(command_string: S, modifiers: SubCommandModifiers) -> Self {
60
+
Self {
61
+
command_string,
62
+
keep_stdin_open: false,
63
+
privilege_escalation_command: None,
64
+
log_stdout: false,
65
+
target: None,
66
+
output_mode: ChildOutputMode::Generic,
67
+
modifiers,
68
+
}
69
+
}
70
+
71
+
pub(crate) const fn execute_on_remote(mut self, target: Option<&'a Target>) -> Self {
72
+
self.target = target;
73
+
self
74
+
}
75
+
76
+
pub(crate) const fn mode(mut self, mode: ChildOutputMode) -> Self {
77
+
self.output_mode = mode;
78
+
self
79
+
}
80
+
81
+
pub(crate) const fn keep_stdin_open(mut self) -> Self {
82
+
self.keep_stdin_open = true;
83
+
self
84
+
}
85
+
86
+
pub(crate) fn elevated(mut self, node: &Node) -> Self {
87
+
self.privilege_escalation_command =
88
+
Some(node.privilege_escalation_command.iter().join(" "));
89
+
self
90
+
}
91
+
92
+
pub(crate) const fn is_elevated(&self) -> bool {
93
+
self.privilege_escalation_command.is_some()
94
+
}
95
+
96
+
pub(crate) const fn log_stdout(mut self) -> Self {
97
+
self.log_stdout = true;
98
+
self
99
+
}
100
+
}
101
+
102
+
pub(crate) async fn run_command<S: AsRef<str>>(
103
+
arguments: &CommandArguments<'_, S>,
104
+
) -> Result<Either<InteractiveChildChip, NonInteractiveChildChip>, HiveLibError> {
105
+
run_command_with_env(arguments, HashMap::new()).await
106
+
}
107
+
108
+
pub(crate) async fn run_command_with_env<S: AsRef<str>>(
109
+
arguments: &CommandArguments<'_, S>,
110
+
envs: HashMap<String, String>,
111
+
) -> Result<Either<InteractiveChildChip, NonInteractiveChildChip>, HiveLibError> {
112
+
// use the non interactive command runner when forced
113
+
// ... or when there is no reason for interactivity, local and unprivileged
114
+
if arguments.modifiers.non_interactive
115
+
|| (arguments.target.is_none() && !arguments.is_elevated())
116
+
{
117
+
return Ok(Either::Right(non_interactive_command_with_env(
118
+
arguments, envs,
119
+
)?));
120
+
}
121
+
122
+
Ok(Either::Left(
123
+
interactive_command_with_env(arguments, envs).await?,
124
+
))
125
+
}
126
+
127
+
pub(crate) trait WireCommandChip {
128
+
type ExitStatus;
129
+
130
+
async fn wait_till_success(self) -> Result<Self::ExitStatus, CommandError>;
131
+
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError>;
132
+
}
133
+
134
+
type ExitStatus = Either<(portable_pty::ExitStatus, String), (std::process::ExitStatus, String)>;
135
+
136
+
impl WireCommandChip for Either<InteractiveChildChip, NonInteractiveChildChip> {
137
+
type ExitStatus = ExitStatus;
138
+
139
+
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
140
+
match self {
141
+
Self::Left(left) => left.write_stdin(data).await,
142
+
Self::Right(right) => right.write_stdin(data).await,
143
+
}
144
+
}
145
+
146
+
async fn wait_till_success(self) -> Result<Self::ExitStatus, CommandError> {
147
+
match self {
148
+
Self::Left(left) => left.wait_till_success().await.map(Either::Left),
149
+
Self::Right(right) => right.wait_till_success().await.map(Either::Right),
150
+
}
151
+
}
152
+
}
153
+
154
+
fn trace_gjson_str<'a>(log: &'a Value<'a>, msg: &'a str) -> Option<String> {
155
+
if msg.is_empty() {
156
+
return None;
157
+
}
158
+
159
+
let level = log.get("level");
160
+
161
+
if !level.exists() {
162
+
return None;
163
+
}
164
+
165
+
let level = match VerbosityLevel::try_from_primitive(level.u64()) {
166
+
Ok(level) => level,
167
+
Err(err) => {
168
+
error!("nix log `level` did not match to a VerbosityLevel: {err:?}");
169
+
return None;
170
+
}
171
+
};
172
+
173
+
let msg = strip_ansi_escapes::strip_str(msg);
174
+
175
+
match level {
176
+
VerbosityLevel::Info => info!("{msg}"),
177
+
VerbosityLevel::Warn | VerbosityLevel::Notice => warn!("{msg}"),
178
+
VerbosityLevel::Error => error!("{msg}"),
179
+
VerbosityLevel::Debug => debug!("{msg}"),
180
+
VerbosityLevel::Vomit | VerbosityLevel::Talkative | VerbosityLevel::Chatty => {
181
+
trace!("{msg}");
182
+
}
183
+
}
184
+
185
+
if matches!(
186
+
level,
187
+
VerbosityLevel::Error | VerbosityLevel::Warn | VerbosityLevel::Notice
188
+
) {
189
+
return Some(msg);
190
+
}
191
+
192
+
None
193
+
}
194
+
195
+
impl ChildOutputMode {
196
+
/// this function is by far the biggest hotspot in the whole tree
197
+
/// Returns a string if this log is notable to be stored as an error message
198
+
fn trace_slice(self, line: &mut [u8]) -> Option<String> {
199
+
let slice = match self {
200
+
Self::Generic | Self::Interactive => {
201
+
let string = String::from_utf8_lossy(line);
202
+
let stripped = strip_ansi_escapes::strip_str(&string);
203
+
warn!("{stripped}");
204
+
return Some(string.to_string());
205
+
}
206
+
Self::Nix => {
207
+
let position = AHO_CORASICK.find(&line).map(|x| &mut line[x.end()..]);
208
+
209
+
if let Some(json_buf) = position {
210
+
json_buf
211
+
} else {
212
+
// usually happens when ssh is outputting something
213
+
warn!("{}", String::from_utf8_lossy(line));
214
+
return None;
215
+
}
216
+
}
217
+
};
218
+
219
+
let Ok(str) = from_utf8(slice) else {
220
+
error!("nix log was not valid utf8!");
221
+
return None;
222
+
};
223
+
224
+
let log = gjson::parse(str);
225
+
226
+
let text = log.get("text");
227
+
228
+
if text.exists() {
229
+
return trace_gjson_str(&log, text.str());
230
+
}
231
+
232
+
let text = log.get("msg");
233
+
234
+
if text.exists() {
235
+
return trace_gjson_str(&log, text.str());
236
+
}
237
+
238
+
None
239
+
}
240
+
}
+199
crates/core/src/commands/noninteractive.rs
+199
crates/core/src/commands/noninteractive.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::{
5
+
collections::{HashMap, VecDeque},
6
+
process::ExitStatus,
7
+
sync::Arc,
8
+
};
9
+
10
+
use crate::{
11
+
SubCommandModifiers,
12
+
commands::{ChildOutputMode, CommandArguments, WireCommandChip},
13
+
errors::{CommandError, HiveLibError},
14
+
hive::node::Target,
15
+
};
16
+
use itertools::Itertools;
17
+
use tokio::{
18
+
io::{AsyncWriteExt, BufReader},
19
+
process::{Child, ChildStdin, Command},
20
+
sync::Mutex,
21
+
task::JoinSet,
22
+
};
23
+
use tracing::{Instrument, debug, instrument, trace};
24
+
25
+
pub(crate) struct NonInteractiveChildChip {
26
+
error_collection: Arc<Mutex<VecDeque<String>>>,
27
+
stdout_collection: Arc<Mutex<VecDeque<String>>>,
28
+
child: Child,
29
+
joinset: JoinSet<()>,
30
+
original_command: String,
31
+
stdin: ChildStdin,
32
+
}
33
+
34
+
#[instrument(skip_all, name = "run", fields(elevated = %arguments.is_elevated()))]
35
+
pub(crate) fn non_interactive_command_with_env<S: AsRef<str>>(
36
+
arguments: &CommandArguments<S>,
37
+
envs: HashMap<String, String>,
38
+
) -> Result<NonInteractiveChildChip, HiveLibError> {
39
+
let mut command = if let Some(target) = arguments.target {
40
+
create_sync_ssh_command(target, arguments.modifiers)?
41
+
} else {
42
+
let mut command = Command::new("sh");
43
+
44
+
command.arg("-c");
45
+
46
+
command
47
+
};
48
+
49
+
let command_string = format!(
50
+
"{command_string}{extra}",
51
+
command_string = arguments.command_string.as_ref(),
52
+
extra = match arguments.output_mode {
53
+
ChildOutputMode::Generic | ChildOutputMode::Interactive => "",
54
+
ChildOutputMode::Nix => " --log-format internal-json",
55
+
}
56
+
);
57
+
58
+
let command_string = if let Some(escalation_command) = &arguments.privilege_escalation_command {
59
+
format!("{escalation_command} sh -c '{command_string}'")
60
+
} else {
61
+
command_string
62
+
};
63
+
64
+
debug!("{command_string}");
65
+
66
+
command.arg(&command_string);
67
+
command.stdin(std::process::Stdio::piped());
68
+
command.stderr(std::process::Stdio::piped());
69
+
command.stdout(std::process::Stdio::piped());
70
+
command.kill_on_drop(true);
71
+
// command.env_clear();
72
+
command.envs(envs);
73
+
74
+
let mut child = command.spawn().unwrap();
75
+
let error_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
76
+
let stdout_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
77
+
let stdin = child.stdin.take().unwrap();
78
+
79
+
let stdout_handle = child
80
+
.stdout
81
+
.take()
82
+
.ok_or(HiveLibError::CommandError(CommandError::NoHandle))?;
83
+
let stderr_handle = child
84
+
.stderr
85
+
.take()
86
+
.ok_or(HiveLibError::CommandError(CommandError::NoHandle))?;
87
+
88
+
let mut joinset = JoinSet::new();
89
+
let output_mode = Arc::new(arguments.output_mode);
90
+
91
+
joinset.spawn(
92
+
handle_io(
93
+
stderr_handle,
94
+
output_mode.clone(),
95
+
error_collection.clone(),
96
+
true,
97
+
true,
98
+
)
99
+
.in_current_span(),
100
+
);
101
+
joinset.spawn(
102
+
handle_io(
103
+
stdout_handle,
104
+
output_mode.clone(),
105
+
stdout_collection.clone(),
106
+
false,
107
+
arguments.log_stdout,
108
+
)
109
+
.in_current_span(),
110
+
);
111
+
112
+
Ok(NonInteractiveChildChip {
113
+
error_collection,
114
+
stdout_collection,
115
+
child,
116
+
joinset,
117
+
original_command: arguments.command_string.as_ref().to_string(),
118
+
stdin,
119
+
})
120
+
}
121
+
122
+
impl WireCommandChip for NonInteractiveChildChip {
123
+
type ExitStatus = (ExitStatus, String);
124
+
125
+
async fn wait_till_success(mut self) -> Result<Self::ExitStatus, CommandError> {
126
+
let status = self.child.wait().await.unwrap();
127
+
let _ = self.joinset.join_all().await;
128
+
129
+
if !status.success() {
130
+
let logs = self.error_collection.lock().await.iter().rev().join("\n");
131
+
132
+
return Err(CommandError::CommandFailed {
133
+
command_ran: self.original_command,
134
+
logs,
135
+
code: match status.code() {
136
+
Some(code) => format!("code {code}"),
137
+
None => "no exit code".to_string(),
138
+
},
139
+
reason: "known-status",
140
+
});
141
+
}
142
+
143
+
let stdout = self.stdout_collection.lock().await.iter().rev().join("\n");
144
+
145
+
Ok((status, stdout))
146
+
}
147
+
148
+
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
149
+
trace!("Writing {} bytes", data.len());
150
+
self.stdin.write_all(&data).await.unwrap();
151
+
Ok(())
152
+
}
153
+
}
154
+
155
+
#[instrument(skip_all, name = "log")]
156
+
pub async fn handle_io<R>(
157
+
reader: R,
158
+
output_mode: Arc<ChildOutputMode>,
159
+
collection: Arc<Mutex<VecDeque<String>>>,
160
+
is_error: bool,
161
+
should_log: bool,
162
+
) where
163
+
R: tokio::io::AsyncRead + Unpin,
164
+
{
165
+
let mut io_reader = tokio::io::AsyncBufReadExt::lines(BufReader::new(reader));
166
+
167
+
while let Some(line) = io_reader.next_line().await.unwrap() {
168
+
let mut line = line.into_bytes();
169
+
170
+
let log = if should_log {
171
+
Some(output_mode.trace_slice(&mut line))
172
+
} else {
173
+
None
174
+
};
175
+
176
+
if !is_error {
177
+
let mut queue = collection.lock().await;
178
+
queue.push_front(String::from_utf8_lossy(&line).to_string());
179
+
} else if let Some(error_msg) = log.flatten() {
180
+
let mut queue = collection.lock().await;
181
+
queue.push_front(error_msg);
182
+
// add at most 20 message to the front, drop the rest.
183
+
queue.truncate(20);
184
+
}
185
+
}
186
+
187
+
debug!("io_handler: goodbye!");
188
+
}
189
+
190
+
fn create_sync_ssh_command(
191
+
target: &Target,
192
+
modifiers: SubCommandModifiers,
193
+
) -> Result<Command, HiveLibError> {
194
+
let mut command = Command::new("ssh");
195
+
command.args(target.create_ssh_args(modifiers, true, false)?);
196
+
command.arg(target.get_preferred_host()?.to_string());
197
+
198
+
Ok(command)
199
+
}
+102
crates/core/src/commands/pty/input.rs
+102
crates/core/src/commands/pty/input.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::os::fd::{AsFd, OwnedFd};
5
+
6
+
use nix::{
7
+
poll::{PollFd, PollFlags, PollTimeout, poll},
8
+
unistd::read,
9
+
};
10
+
use tracing::{Span, debug, error, instrument, trace};
11
+
12
+
use crate::{
13
+
commands::pty::{MasterWriter, THREAD_BEGAN_SIGNAL, THREAD_QUIT_SIGNAL},
14
+
errors::CommandError,
15
+
};
16
+
17
+
/// Exits on any data written to `cancel_pipe_r`
18
+
/// A pipe is used to cancel the function.
19
+
#[instrument(skip_all, level = "trace", parent = span)]
20
+
pub(super) fn watch_stdin_from_user(
21
+
cancel_pipe_r: &OwnedFd,
22
+
mut master_writer: MasterWriter,
23
+
write_pipe_r: &OwnedFd,
24
+
span: Span,
25
+
) -> Result<(), CommandError> {
26
+
const WRITER_POSITION: usize = 0;
27
+
const SIGNAL_POSITION: usize = 1;
28
+
const USER_POSITION: usize = 2;
29
+
30
+
let mut buffer = [0u8; 1024];
31
+
let stdin = std::io::stdin();
32
+
let mut cancel_pipe_buf = [0u8; 1];
33
+
34
+
let user_stdin_fd = stdin.as_fd();
35
+
let cancel_pipe_r_fd = cancel_pipe_r.as_fd();
36
+
37
+
let mut all_fds = vec![
38
+
PollFd::new(write_pipe_r.as_fd(), PollFlags::POLLIN),
39
+
PollFd::new(cancel_pipe_r.as_fd(), PollFlags::POLLIN),
40
+
PollFd::new(user_stdin_fd, PollFlags::POLLIN),
41
+
];
42
+
43
+
loop {
44
+
match poll(&mut all_fds, PollTimeout::NONE) {
45
+
Ok(0) => {} // timeout, impossible
46
+
Ok(_) => {
47
+
// The user stdin pipe can be removed
48
+
if all_fds.get(USER_POSITION).is_some()
49
+
&& let Some(events) = all_fds[USER_POSITION].revents()
50
+
&& events.contains(PollFlags::POLLIN)
51
+
{
52
+
trace!("Got stdin from user...");
53
+
let n = read(user_stdin_fd, &mut buffer).map_err(CommandError::PosixPipe)?;
54
+
master_writer
55
+
.write_all(&buffer[..n])
56
+
.map_err(CommandError::WritingMasterStdout)?;
57
+
master_writer
58
+
.flush()
59
+
.map_err(CommandError::WritingMasterStdout)?;
60
+
}
61
+
62
+
if let Some(events) = all_fds[WRITER_POSITION].revents()
63
+
&& events.contains(PollFlags::POLLIN)
64
+
{
65
+
trace!("Got stdin from writer...");
66
+
let n = read(write_pipe_r, &mut buffer).map_err(CommandError::PosixPipe)?;
67
+
master_writer
68
+
.write_all(&buffer[..n])
69
+
.map_err(CommandError::WritingMasterStdout)?;
70
+
master_writer
71
+
.flush()
72
+
.map_err(CommandError::WritingMasterStdout)?;
73
+
}
74
+
75
+
if let Some(events) = all_fds[SIGNAL_POSITION].revents()
76
+
&& events.contains(PollFlags::POLLIN)
77
+
{
78
+
let n = read(cancel_pipe_r_fd, &mut cancel_pipe_buf)
79
+
.map_err(CommandError::PosixPipe)?;
80
+
let message = &cancel_pipe_buf[..n];
81
+
82
+
trace!("Got byte from signal pipe: {message:?}");
83
+
84
+
if message == THREAD_QUIT_SIGNAL {
85
+
return Ok(());
86
+
}
87
+
88
+
if message == THREAD_BEGAN_SIGNAL {
89
+
all_fds.remove(USER_POSITION);
90
+
}
91
+
}
92
+
}
93
+
Err(e) => {
94
+
error!("Poll error: {e}");
95
+
break;
96
+
}
97
+
}
98
+
}
99
+
100
+
debug!("stdin_thread: goodbye");
101
+
Ok(())
102
+
}
+63
crates/core/src/commands/pty/logbuffer.rs
+63
crates/core/src/commands/pty/logbuffer.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
/// Split into its own struct to be tested nicer
5
+
pub(crate) struct LogBuffer {
6
+
buffer: Vec<u8>,
7
+
}
8
+
9
+
impl LogBuffer {
10
+
pub const fn new() -> Self {
11
+
Self { buffer: Vec::new() }
12
+
}
13
+
14
+
pub fn process_slice(&mut self, slice: &[u8]) {
15
+
self.buffer.extend_from_slice(slice);
16
+
}
17
+
18
+
pub fn next_line(&mut self) -> Option<Vec<u8>> {
19
+
let line_end = self.buffer.iter().position(|x| *x == b'\n')?;
20
+
21
+
let drained = self.buffer.drain(..line_end).collect();
22
+
self.buffer.remove(0);
23
+
Some(drained)
24
+
}
25
+
26
+
#[cfg(test)]
27
+
fn take_lines(&mut self) -> Vec<Vec<u8>> {
28
+
let mut lines = vec![];
29
+
30
+
while let Some(line) = self.next_line() {
31
+
lines.push(line);
32
+
}
33
+
34
+
lines
35
+
}
36
+
}
37
+
38
+
#[cfg(test)]
39
+
mod tests {
40
+
use super::*;
41
+
42
+
#[test]
43
+
fn test_split_line_processing() {
44
+
let mut log_buffer = LogBuffer::new();
45
+
46
+
log_buffer.process_slice(b"Writing key KeySpec { destination: \"/et");
47
+
log_buffer.process_slice(b"c/keys/buildbot.aws.key\", user: \"buildbot\", group: \"buildbot-worker\", permissions: 384, length: 32, last: false, crc: 1370815231 }, 32 bytes of data");
48
+
log_buffer.process_slice(b"\n");
49
+
log_buffer.process_slice(b"xxx");
50
+
log_buffer.process_slice(b"xx_WIRE");
51
+
log_buffer.process_slice(b"_QUIT\n");
52
+
let lines = log_buffer.take_lines();
53
+
assert_eq!(lines.len(), 2);
54
+
assert_eq!(
55
+
String::from_utf8_lossy(lines.first().unwrap()),
56
+
"Writing key KeySpec { destination: \"/etc/keys/buildbot.aws.key\", user: \"buildbot\", group: \"buildbot-worker\", permissions: 384, length: 32, last: false, crc: 1370815231 }, 32 bytes of data"
57
+
);
58
+
assert_eq!(lines.get(1), Some(&"xxxxx_WIRE_QUIT".as_bytes().to_vec()));
59
+
60
+
// taking leaves none
61
+
assert_eq!(log_buffer.take_lines().len(), 0);
62
+
}
63
+
}
+566
crates/core/src/commands/pty/mod.rs
+566
crates/core/src/commands/pty/mod.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use crate::commands::pty::output::{WatchStdoutArguments, handle_pty_stdout};
5
+
use crate::status::STATUS;
6
+
use aho_corasick::PatternID;
7
+
use itertools::Itertools;
8
+
use nix::sys::termios::{LocalFlags, SetArg, Termios, tcgetattr, tcsetattr};
9
+
use nix::unistd::pipe;
10
+
use nix::unistd::write as posix_write;
11
+
use portable_pty::{CommandBuilder, NativePtySystem, PtyPair, PtySize};
12
+
use rand::distr::Alphabetic;
13
+
use std::collections::VecDeque;
14
+
use std::io::stderr;
15
+
use std::sync::{LazyLock, Mutex};
16
+
use std::{
17
+
io::{Read, Write},
18
+
os::fd::{AsFd, OwnedFd},
19
+
sync::Arc,
20
+
};
21
+
use tokio::sync::{oneshot, watch};
22
+
use tracing::instrument;
23
+
use tracing::{Span, debug, trace};
24
+
25
+
use crate::commands::CommandArguments;
26
+
use crate::commands::pty::input::watch_stdin_from_user;
27
+
use crate::errors::CommandError;
28
+
use crate::{SubCommandModifiers, acquire_stdin_lock};
29
+
use crate::{
30
+
commands::{ChildOutputMode, WireCommandChip},
31
+
errors::HiveLibError,
32
+
hive::node::Target,
33
+
};
34
+
35
+
mod input;
36
+
mod logbuffer;
37
+
mod output;
38
+
39
+
type MasterWriter = Box<dyn Write + Send>;
40
+
type MasterReader = Box<dyn Read + Send>;
41
+
42
+
/// the underlying command began
43
+
const THREAD_BEGAN_SIGNAL: &[u8; 1] = b"b";
44
+
const THREAD_QUIT_SIGNAL: &[u8; 1] = b"q";
45
+
46
+
type Child = Box<dyn portable_pty::Child + Send + Sync>;
47
+
48
+
pub(crate) struct InteractiveChildChip {
49
+
child: Child,
50
+
51
+
cancel_stdin_pipe_w: OwnedFd,
52
+
write_stdin_pipe_w: OwnedFd,
53
+
54
+
stderr_collection: Arc<Mutex<VecDeque<String>>>,
55
+
stdout_collection: Arc<Mutex<VecDeque<String>>>,
56
+
57
+
original_command: String,
58
+
59
+
status_receiver: watch::Receiver<Status>,
60
+
stdout_handle: tokio::task::JoinHandle<Result<(), CommandError>>,
61
+
}
62
+
63
+
/// sets and reverts terminal options (the terminal user interaction is performed)
64
+
/// reverts data when dropped
65
+
struct StdinTermiosAttrGuard(Termios);
66
+
67
+
#[derive(Debug)]
68
+
enum Status {
69
+
Running,
70
+
Done { success: bool },
71
+
}
72
+
73
+
#[derive(Debug)]
74
+
enum SearchFindings {
75
+
None,
76
+
Started,
77
+
Terminate,
78
+
}
79
+
80
+
static STARTED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(0));
81
+
static SUCCEEDED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(1));
82
+
static FAILED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(2));
83
+
84
+
/// substitutes STDOUT with #$line. stdout is far less common than stderr.
85
+
const IO_SUBS: &str = "1> >(while IFS= read -r line; do echo \"#$line\"; done)";
86
+
87
+
fn create_ending_segment<S: AsRef<str>>(
88
+
arguments: &CommandArguments<'_, S>,
89
+
needles: &Needles,
90
+
) -> String {
91
+
let Needles {
92
+
succeed,
93
+
fail,
94
+
start,
95
+
} = needles;
96
+
97
+
format!(
98
+
"echo -e '{succeed}' || echo '{failed}'",
99
+
succeed = if matches!(arguments.output_mode, ChildOutputMode::Interactive) {
100
+
format!(
101
+
"{start}\\n{succeed}",
102
+
start = String::from_utf8_lossy(start),
103
+
succeed = String::from_utf8_lossy(succeed)
104
+
)
105
+
} else {
106
+
String::from_utf8_lossy(succeed).to_string()
107
+
},
108
+
failed = String::from_utf8_lossy(fail)
109
+
)
110
+
}
111
+
112
+
fn create_starting_segment<S: AsRef<str>>(
113
+
arguments: &CommandArguments<'_, S>,
114
+
start_needle: &Arc<Vec<u8>>,
115
+
) -> String {
116
+
if matches!(arguments.output_mode, ChildOutputMode::Interactive) {
117
+
String::new()
118
+
} else {
119
+
format!(
120
+
"echo '{start}' && ",
121
+
start = String::from_utf8_lossy(start_needle)
122
+
)
123
+
}
124
+
}
125
+
126
+
#[instrument(skip_all, name = "run-int", fields(elevated = %arguments.is_elevated(), mode = ?arguments.output_mode))]
127
+
pub(crate) async fn interactive_command_with_env<S: AsRef<str>>(
128
+
arguments: &CommandArguments<'_, S>,
129
+
envs: std::collections::HashMap<String, String>,
130
+
) -> Result<InteractiveChildChip, HiveLibError> {
131
+
print_authenticate_warning(arguments)?;
132
+
133
+
let needles = create_needles();
134
+
let pty_system = NativePtySystem::default();
135
+
let pty_pair = portable_pty::PtySystem::openpty(&pty_system, PtySize::default()).unwrap();
136
+
setup_master(&pty_pair)?;
137
+
138
+
let command_string = &format!(
139
+
"{starting}{command} {flags} {IO_SUBS} && {ending}",
140
+
command = arguments.command_string.as_ref(),
141
+
flags = match arguments.output_mode {
142
+
ChildOutputMode::Nix => "--log-format internal-json",
143
+
ChildOutputMode::Generic | ChildOutputMode::Interactive => "",
144
+
},
145
+
starting = create_starting_segment(arguments, &needles.start),
146
+
ending = create_ending_segment(arguments, &needles)
147
+
);
148
+
149
+
debug!("{command_string}");
150
+
151
+
let mut command = build_command(arguments, command_string)?;
152
+
153
+
// give command all env vars
154
+
for (key, value) in envs {
155
+
command.env(key, value);
156
+
}
157
+
158
+
let clobber_guard = acquire_stdin_lock().await;
159
+
let _guard = StdinTermiosAttrGuard::new().map_err(HiveLibError::CommandError)?;
160
+
let child = pty_pair
161
+
.slave
162
+
.spawn_command(command)
163
+
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
164
+
165
+
// Release any handles owned by the slave: we don't need it now
166
+
// that we've spawned the child.
167
+
drop(pty_pair.slave);
168
+
169
+
let reader = pty_pair
170
+
.master
171
+
.try_clone_reader()
172
+
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
173
+
let master_writer = pty_pair
174
+
.master
175
+
.take_writer()
176
+
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
177
+
178
+
let stderr_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
179
+
let stdout_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
180
+
let (began_tx, began_rx) = oneshot::channel::<()>();
181
+
let (status_sender, status_receiver) = watch::channel(Status::Running);
182
+
183
+
let stdout_handle = {
184
+
let arguments = WatchStdoutArguments {
185
+
began_tx,
186
+
reader,
187
+
needles,
188
+
output_mode: arguments.output_mode,
189
+
stderr_collection: stderr_collection.clone(),
190
+
stdout_collection: stdout_collection.clone(),
191
+
span: Span::current(),
192
+
log_stdout: arguments.log_stdout,
193
+
status_sender,
194
+
};
195
+
196
+
tokio::task::spawn_blocking(move || handle_pty_stdout(arguments))
197
+
};
198
+
199
+
let (write_stdin_pipe_r, write_stdin_pipe_w) =
200
+
pipe().map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
201
+
let (cancel_stdin_pipe_r, cancel_stdin_pipe_w) =
202
+
pipe().map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
203
+
204
+
tokio::task::spawn_blocking(move || {
205
+
watch_stdin_from_user(
206
+
&cancel_stdin_pipe_r,
207
+
master_writer,
208
+
&write_stdin_pipe_r,
209
+
Span::current(),
210
+
)
211
+
});
212
+
213
+
debug!("Setup threads");
214
+
215
+
let () = began_rx
216
+
.await
217
+
.map_err(|x| HiveLibError::CommandError(CommandError::OneshotRecvError(x)))?;
218
+
219
+
drop(clobber_guard);
220
+
221
+
if arguments.keep_stdin_open {
222
+
trace!("Sending THREAD_BEGAN_SIGNAL");
223
+
224
+
posix_write(&cancel_stdin_pipe_w, THREAD_BEGAN_SIGNAL)
225
+
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
226
+
} else {
227
+
trace!("Sending THREAD_QUIT_SIGNAL");
228
+
229
+
posix_write(&cancel_stdin_pipe_w, THREAD_QUIT_SIGNAL)
230
+
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
231
+
}
232
+
233
+
Ok(InteractiveChildChip {
234
+
child,
235
+
cancel_stdin_pipe_w,
236
+
write_stdin_pipe_w,
237
+
stderr_collection,
238
+
stdout_collection,
239
+
original_command: arguments.command_string.as_ref().to_string(),
240
+
status_receiver,
241
+
stdout_handle,
242
+
})
243
+
}
244
+
245
+
fn print_authenticate_warning<S: AsRef<str>>(
246
+
arguments: &CommandArguments<S>,
247
+
) -> Result<(), HiveLibError> {
248
+
if !arguments.is_elevated() {
249
+
return Ok(());
250
+
}
251
+
252
+
let _ = STATUS.lock().write_above_status(
253
+
&format!(
254
+
"{} | Authenticate for \"sudo {}\":\n",
255
+
arguments
256
+
.target
257
+
.map_or(Ok("localhost (!)".to_string()), |target| Ok(format!(
258
+
"{}@{}:{}",
259
+
target.user,
260
+
target.get_preferred_host()?,
261
+
target.port
262
+
)))?,
263
+
arguments.command_string.as_ref()
264
+
)
265
+
.into_bytes(),
266
+
&mut stderr(),
267
+
);
268
+
269
+
Ok(())
270
+
}
271
+
272
+
struct Needles {
273
+
succeed: Arc<Vec<u8>>,
274
+
fail: Arc<Vec<u8>>,
275
+
start: Arc<Vec<u8>>,
276
+
}
277
+
278
+
fn create_needles() -> Needles {
279
+
let tmp_prefix = rand::distr::SampleString::sample_string(&Alphabetic, &mut rand::rng(), 5);
280
+
281
+
Needles {
282
+
succeed: Arc::new(format!("{tmp_prefix}_W_Q").as_bytes().to_vec()),
283
+
fail: Arc::new(format!("{tmp_prefix}_W_F").as_bytes().to_vec()),
284
+
start: Arc::new(format!("{tmp_prefix}_W_S").as_bytes().to_vec()),
285
+
}
286
+
}
287
+
288
+
fn setup_master(pty_pair: &PtyPair) -> Result<(), HiveLibError> {
289
+
if let Some(fd) = pty_pair.master.as_raw_fd() {
290
+
// convert raw fd to a BorrowedFd
291
+
// safe as `fd` is dropped well before `pty_pair.master`
292
+
let fd = unsafe { std::os::unix::io::BorrowedFd::borrow_raw(fd) };
293
+
let mut termios =
294
+
tcgetattr(fd).map_err(|x| HiveLibError::CommandError(CommandError::TermAttrs(x)))?;
295
+
296
+
termios.local_flags &= !LocalFlags::ECHO;
297
+
// Key agent does not work well without canonical mode
298
+
termios.local_flags &= !LocalFlags::ICANON;
299
+
// Actually quit
300
+
termios.local_flags &= !LocalFlags::ISIG;
301
+
302
+
tcsetattr(fd, SetArg::TCSANOW, &termios)
303
+
.map_err(|x| HiveLibError::CommandError(CommandError::TermAttrs(x)))?;
304
+
}
305
+
306
+
Ok(())
307
+
}
308
+
309
+
fn build_command<S: AsRef<str>>(
310
+
arguments: &CommandArguments<'_, S>,
311
+
command_string: &String,
312
+
) -> Result<CommandBuilder, HiveLibError> {
313
+
let mut command = if let Some(target) = arguments.target {
314
+
let mut command = create_int_ssh_command(target, arguments.modifiers)?;
315
+
316
+
// force ssh to use our pseudo terminal
317
+
command.arg("-tt");
318
+
319
+
command
320
+
} else {
321
+
let mut command = portable_pty::CommandBuilder::new("sh");
322
+
323
+
command.arg("-c");
324
+
325
+
command
326
+
};
327
+
328
+
if arguments.is_elevated() {
329
+
command.arg(format!("sudo -u root -- sh -c '{command_string}'"));
330
+
} else {
331
+
command.arg(command_string);
332
+
}
333
+
334
+
Ok(command)
335
+
}
336
+
337
+
impl WireCommandChip for InteractiveChildChip {
338
+
type ExitStatus = (portable_pty::ExitStatus, String);
339
+
340
+
#[instrument(skip_all)]
341
+
async fn wait_till_success(mut self) -> Result<Self::ExitStatus, CommandError> {
342
+
drop(self.write_stdin_pipe_w);
343
+
344
+
let exit_status = tokio::task::spawn_blocking(move || self.child.wait())
345
+
.await
346
+
.map_err(CommandError::JoinError)?
347
+
.map_err(CommandError::WaitForStatus)?;
348
+
349
+
debug!("exit_status: {exit_status:?}");
350
+
351
+
self.stdout_handle
352
+
.await
353
+
.map_err(|_| CommandError::ThreadPanic)??;
354
+
355
+
let status = self
356
+
.status_receiver
357
+
.wait_for(|value| matches!(value, Status::Done { .. }))
358
+
.await
359
+
.unwrap();
360
+
361
+
let _ = posix_write(&self.cancel_stdin_pipe_w, THREAD_QUIT_SIGNAL);
362
+
363
+
if let Status::Done { success: true } = *status {
364
+
let logs = self
365
+
.stdout_collection
366
+
.lock()
367
+
.unwrap()
368
+
.iter()
369
+
.rev()
370
+
.map(|x| x.trim())
371
+
.join("\n");
372
+
373
+
return Ok((exit_status, logs));
374
+
}
375
+
376
+
debug!("child did not succeed");
377
+
378
+
let logs = self
379
+
.stderr_collection
380
+
.lock()
381
+
.unwrap()
382
+
.iter()
383
+
.rev()
384
+
.join("\n");
385
+
386
+
Err(CommandError::CommandFailed {
387
+
command_ran: self.original_command,
388
+
logs,
389
+
code: format!("code {}", exit_status.exit_code()),
390
+
reason: match *status {
391
+
Status::Done { .. } => "marked-unsuccessful",
392
+
Status::Running => "child-crashed-before-succeeding",
393
+
},
394
+
})
395
+
}
396
+
397
+
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
398
+
trace!("Writing {} bytes to stdin", data.len());
399
+
400
+
posix_write(&self.write_stdin_pipe_w, &data)
401
+
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
402
+
403
+
Ok(())
404
+
}
405
+
}
406
+
407
+
impl StdinTermiosAttrGuard {
408
+
fn new() -> Result<Self, CommandError> {
409
+
let stdin = std::io::stdin();
410
+
let stdin_fd = stdin.as_fd();
411
+
412
+
let mut termios = tcgetattr(stdin_fd).map_err(CommandError::TermAttrs)?;
413
+
let original_termios = termios.clone();
414
+
415
+
termios.local_flags &= !(LocalFlags::ECHO | LocalFlags::ICANON);
416
+
tcsetattr(stdin_fd, SetArg::TCSANOW, &termios).map_err(CommandError::TermAttrs)?;
417
+
418
+
Ok(StdinTermiosAttrGuard(original_termios))
419
+
}
420
+
}
421
+
422
+
impl Drop for StdinTermiosAttrGuard {
423
+
fn drop(&mut self) {
424
+
let stdin = std::io::stdin();
425
+
let stdin_fd = stdin.as_fd();
426
+
427
+
let _ = tcsetattr(stdin_fd, SetArg::TCSANOW, &self.0);
428
+
}
429
+
}
430
+
431
+
fn create_int_ssh_command(
432
+
target: &Target,
433
+
modifiers: SubCommandModifiers,
434
+
) -> Result<portable_pty::CommandBuilder, HiveLibError> {
435
+
let mut command = portable_pty::CommandBuilder::new("ssh");
436
+
command.args(target.create_ssh_args(modifiers, false, false)?);
437
+
command.arg(target.get_preferred_host()?.to_string());
438
+
Ok(command)
439
+
}
440
+
441
+
#[cfg(test)]
442
+
mod tests {
443
+
use aho_corasick::AhoCorasick;
444
+
use tokio::sync::oneshot::error::TryRecvError;
445
+
446
+
use crate::commands::pty::output::handle_rawmode_data;
447
+
448
+
use super::*;
449
+
use std::assert_matches::assert_matches;
450
+
451
+
#[test]
452
+
fn test_rawmode_data() {
453
+
let aho_corasick = AhoCorasick::builder()
454
+
.ascii_case_insensitive(false)
455
+
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
456
+
.build(["START_NEEDLE", "SUCCEEDED_NEEDLE", "FAILED_NEEDLE"])
457
+
.unwrap();
458
+
let mut stderr = vec![];
459
+
let (began_tx, mut began_rx) = oneshot::channel::<()>();
460
+
let mut began_tx = Some(began_tx);
461
+
let (status_sender, _) = watch::channel(Status::Running);
462
+
463
+
// each "Bla" is 4 bytes.
464
+
let buffer = "bla bla bla START_NEEDLE bla bla bla".as_bytes();
465
+
let mut raw_mode_buffer = vec![];
466
+
467
+
// handle 1 "bla"
468
+
assert_matches!(
469
+
handle_rawmode_data(
470
+
&mut stderr,
471
+
buffer,
472
+
4,
473
+
&mut raw_mode_buffer,
474
+
&aho_corasick,
475
+
&status_sender,
476
+
&mut began_tx
477
+
),
478
+
Ok(SearchFindings::None)
479
+
);
480
+
assert_matches!(began_rx.try_recv(), Err(TryRecvError::Empty));
481
+
assert!(began_tx.is_some());
482
+
assert_eq!(raw_mode_buffer, b"bla ");
483
+
assert_matches!(*status_sender.borrow(), Status::Running);
484
+
485
+
let buffer = &buffer[4..];
486
+
487
+
// handle 2 "bla"'s and half a "START_NEEDLE"
488
+
let n = 4 + 4 + 6;
489
+
assert_matches!(
490
+
handle_rawmode_data(
491
+
&mut stderr,
492
+
buffer,
493
+
n,
494
+
&mut raw_mode_buffer,
495
+
&aho_corasick,
496
+
&status_sender,
497
+
&mut began_tx
498
+
),
499
+
Ok(SearchFindings::None)
500
+
);
501
+
assert_matches!(began_rx.try_recv(), Err(TryRecvError::Empty));
502
+
assert!(began_tx.is_some());
503
+
assert_matches!(*status_sender.borrow(), Status::Running);
504
+
assert_eq!(raw_mode_buffer, b"bla bla bla START_");
505
+
506
+
let buffer = &buffer[n..];
507
+
508
+
// handle rest of the data
509
+
let n = buffer.len();
510
+
assert_matches!(
511
+
handle_rawmode_data(
512
+
&mut stderr,
513
+
buffer,
514
+
n,
515
+
&mut raw_mode_buffer,
516
+
&aho_corasick,
517
+
&status_sender,
518
+
&mut began_tx
519
+
),
520
+
Ok(SearchFindings::Started)
521
+
);
522
+
assert_matches!(began_rx.try_recv(), Ok(()));
523
+
assert_matches!(began_tx, None);
524
+
assert_eq!(raw_mode_buffer, b"bla bla bla START_NEEDLE bla bla bla");
525
+
assert_matches!(*status_sender.borrow(), Status::Running);
526
+
527
+
// test failed needle
528
+
let buffer = "bla FAILED_NEEDLE bla".as_bytes();
529
+
let mut raw_mode_buffer = vec![];
530
+
531
+
let n = buffer.len();
532
+
assert_matches!(
533
+
handle_rawmode_data(
534
+
&mut stderr,
535
+
buffer,
536
+
n,
537
+
&mut raw_mode_buffer,
538
+
&aho_corasick,
539
+
&status_sender,
540
+
&mut began_tx
541
+
),
542
+
Ok(SearchFindings::Terminate)
543
+
);
544
+
assert_matches!(*status_sender.borrow(), Status::Done { success: false });
545
+
546
+
// test succeed needle
547
+
let buffer = "bla SUCCEEDED_NEEDLE bla".as_bytes();
548
+
let mut raw_mode_buffer = vec![];
549
+
let (status_sender, _) = watch::channel(Status::Running);
550
+
551
+
let n = buffer.len();
552
+
assert_matches!(
553
+
handle_rawmode_data(
554
+
&mut stderr,
555
+
buffer,
556
+
n,
557
+
&mut raw_mode_buffer,
558
+
&aho_corasick,
559
+
&status_sender,
560
+
&mut began_tx
561
+
),
562
+
Ok(SearchFindings::Terminate)
563
+
);
564
+
assert_matches!(*status_sender.borrow(), Status::Done { success: true });
565
+
}
566
+
}
+264
crates/core/src/commands/pty/output.rs
+264
crates/core/src/commands/pty/output.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use crate::{
5
+
commands::{
6
+
ChildOutputMode,
7
+
pty::{
8
+
FAILED_PATTERN, Needles, STARTED_PATTERN, SUCCEEDED_PATTERN, SearchFindings, Status,
9
+
logbuffer::LogBuffer,
10
+
},
11
+
},
12
+
errors::CommandError,
13
+
};
14
+
use aho_corasick::AhoCorasick;
15
+
use std::{
16
+
collections::VecDeque,
17
+
io::Write,
18
+
sync::{Arc, Mutex},
19
+
};
20
+
use tokio::sync::{oneshot, watch};
21
+
use tracing::{Span, debug, instrument};
22
+
23
+
pub(super) struct WatchStdoutArguments {
24
+
pub began_tx: oneshot::Sender<()>,
25
+
pub reader: super::MasterReader,
26
+
pub needles: Needles,
27
+
pub output_mode: ChildOutputMode,
28
+
pub stderr_collection: Arc<Mutex<VecDeque<String>>>,
29
+
pub stdout_collection: Arc<Mutex<VecDeque<String>>>,
30
+
pub status_sender: watch::Sender<Status>,
31
+
pub span: Span,
32
+
pub log_stdout: bool,
33
+
}
34
+
35
+
/// Handles data from the PTY, and logs or prompts the user depending on the state
36
+
/// of the command.
37
+
///
38
+
/// Emits a message on the `began_tx` when the command is considered started.
39
+
///
40
+
/// Records stderr and stdout when it is considered notable (all stdout, last few stderr messages)
41
+
#[instrument(skip_all, name = "log", parent = arguments.span)]
42
+
pub(super) fn handle_pty_stdout(arguments: WatchStdoutArguments) -> Result<(), CommandError> {
43
+
let WatchStdoutArguments {
44
+
began_tx,
45
+
mut reader,
46
+
needles,
47
+
output_mode,
48
+
stdout_collection,
49
+
stderr_collection,
50
+
status_sender,
51
+
log_stdout,
52
+
..
53
+
} = arguments;
54
+
55
+
let aho_corasick = AhoCorasick::builder()
56
+
.ascii_case_insensitive(false)
57
+
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
58
+
.build([
59
+
needles.start.as_ref(),
60
+
needles.succeed.as_ref(),
61
+
needles.fail.as_ref(),
62
+
])
63
+
.unwrap();
64
+
65
+
let mut buffer = [0u8; 1024];
66
+
let mut stderr = std::io::stderr();
67
+
let mut began = false;
68
+
let mut log_buffer = LogBuffer::new();
69
+
let mut raw_mode_buffer = Vec::new();
70
+
let mut belled = false;
71
+
let mut began_tx = Some(began_tx);
72
+
73
+
'outer: loop {
74
+
match reader.read(&mut buffer) {
75
+
Ok(0) => break 'outer,
76
+
Ok(n) => {
77
+
// this block is responsible for outputting the "raw" data,
78
+
// mostly sudo prompts.
79
+
if !began {
80
+
let findings = handle_rawmode_data(
81
+
&mut stderr,
82
+
&buffer,
83
+
n,
84
+
&mut raw_mode_buffer,
85
+
&aho_corasick,
86
+
&status_sender,
87
+
&mut began_tx,
88
+
)?;
89
+
90
+
match findings {
91
+
SearchFindings::Terminate => break 'outer,
92
+
SearchFindings::Started => {
93
+
began = true;
94
+
continue;
95
+
}
96
+
SearchFindings::None => {}
97
+
}
98
+
99
+
if belled {
100
+
continue;
101
+
}
102
+
103
+
stderr
104
+
.write(b"\x07") // bell
105
+
.map_err(CommandError::WritingClientStderr)?;
106
+
stderr.flush().map_err(CommandError::WritingClientStderr)?;
107
+
108
+
belled = true;
109
+
110
+
continue;
111
+
}
112
+
113
+
log_buffer.process_slice(&buffer[..n]);
114
+
115
+
while let Some(mut line) = log_buffer.next_line() {
116
+
let findings =
117
+
search_string(&aho_corasick, &line, &status_sender, &mut began_tx);
118
+
119
+
match findings {
120
+
SearchFindings::Terminate => break 'outer,
121
+
SearchFindings::Started => {
122
+
began = true;
123
+
continue;
124
+
}
125
+
SearchFindings::None => {}
126
+
}
127
+
128
+
handle_normal_data(
129
+
&stderr_collection,
130
+
&stdout_collection,
131
+
&mut line,
132
+
log_stdout,
133
+
output_mode,
134
+
);
135
+
}
136
+
}
137
+
Err(e) => {
138
+
eprintln!("Error reading from PTY: {e}");
139
+
break;
140
+
}
141
+
}
142
+
}
143
+
144
+
began_tx.map(|began_tx| began_tx.send(()));
145
+
146
+
// failsafe if there were errors or the reader stopped
147
+
if matches!(*status_sender.borrow(), Status::Running) {
148
+
status_sender.send_replace(Status::Done { success: false });
149
+
}
150
+
151
+
debug!("stdout: goodbye");
152
+
153
+
Ok(())
154
+
}
155
+
156
+
/// handles raw data, prints to stderr when a prompt is detected
157
+
pub(super) fn handle_rawmode_data<W: std::io::Write>(
158
+
stderr: &mut W,
159
+
buffer: &[u8],
160
+
n: usize,
161
+
raw_mode_buffer: &mut Vec<u8>,
162
+
aho_corasick: &AhoCorasick,
163
+
status_sender: &watch::Sender<Status>,
164
+
began_tx: &mut Option<oneshot::Sender<()>>,
165
+
) -> Result<SearchFindings, CommandError> {
166
+
raw_mode_buffer.extend_from_slice(&buffer[..n]);
167
+
168
+
let findings = search_string(aho_corasick, raw_mode_buffer, status_sender, began_tx);
169
+
170
+
if matches!(
171
+
findings,
172
+
SearchFindings::Started | SearchFindings::Terminate
173
+
) {
174
+
return Ok(findings);
175
+
}
176
+
177
+
stderr
178
+
.write_all(&buffer[..n])
179
+
.map_err(CommandError::WritingClientStderr)?;
180
+
181
+
stderr.flush().map_err(CommandError::WritingClientStderr)?;
182
+
183
+
Ok(findings)
184
+
}
185
+
186
+
/// handles data when the command is considered "started", logs and records errors as appropriate
187
+
fn handle_normal_data(
188
+
stderr_collection: &Arc<Mutex<VecDeque<String>>>,
189
+
stdout_collection: &Arc<Mutex<VecDeque<String>>>,
190
+
line: &mut [u8],
191
+
log_stdout: bool,
192
+
output_mode: ChildOutputMode,
193
+
) {
194
+
if line.starts_with(b"#") {
195
+
let stripped = &mut line[1..];
196
+
197
+
if log_stdout {
198
+
output_mode.trace_slice(stripped);
199
+
}
200
+
201
+
let mut queue = stdout_collection.lock().unwrap();
202
+
queue.push_front(String::from_utf8_lossy(stripped).to_string());
203
+
return;
204
+
}
205
+
206
+
let log = output_mode.trace_slice(line);
207
+
208
+
if let Some(error_msg) = log {
209
+
let mut queue = stderr_collection.lock().unwrap();
210
+
211
+
// add at most 20 message to the front, drop the rest.
212
+
queue.push_front(error_msg);
213
+
queue.truncate(20);
214
+
}
215
+
}
216
+
217
+
/// returns true if the command is considered stopped
218
+
fn search_string(
219
+
aho_corasick: &AhoCorasick,
220
+
haystack: &[u8],
221
+
status_sender: &watch::Sender<Status>,
222
+
began_tx: &mut Option<oneshot::Sender<()>>,
223
+
) -> SearchFindings {
224
+
let searched = aho_corasick
225
+
.find_iter(haystack)
226
+
.map(|x| x.pattern())
227
+
.collect::<Vec<_>>();
228
+
229
+
let started = if searched.contains(&STARTED_PATTERN) {
230
+
debug!("start needle was found, switching mode...");
231
+
if let Some(began_tx) = began_tx.take() {
232
+
let _ = began_tx.send(());
233
+
}
234
+
true
235
+
} else {
236
+
false
237
+
};
238
+
239
+
let succeeded = if searched.contains(&SUCCEEDED_PATTERN) {
240
+
debug!("succeed needle was found, marking child as succeeding.");
241
+
status_sender.send_replace(Status::Done { success: true });
242
+
true
243
+
} else {
244
+
false
245
+
};
246
+
247
+
let failed = if searched.contains(&FAILED_PATTERN) {
248
+
debug!("failed needle was found, elevated child did not succeed.");
249
+
status_sender.send_replace(Status::Done { success: false });
250
+
true
251
+
} else {
252
+
false
253
+
};
254
+
255
+
if succeeded || failed {
256
+
return SearchFindings::Terminate;
257
+
}
258
+
259
+
if started {
260
+
return SearchFindings::Started;
261
+
}
262
+
263
+
SearchFindings::None
264
+
}
+376
crates/core/src/errors.rs
+376
crates/core/src/errors.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#![allow(unused_assignments)]
5
+
6
+
use std::{num::ParseIntError, path::PathBuf, process::ExitStatus, sync::mpsc::RecvError};
7
+
8
+
use miette::{Diagnostic, SourceSpan};
9
+
use nix_compat::flakeref::{FlakeRef, FlakeRefError};
10
+
use thiserror::Error;
11
+
use tokio::task::JoinError;
12
+
13
+
use crate::hive::node::{Name, SwitchToConfigurationGoal};
14
+
15
+
#[cfg(debug_assertions)]
16
+
const DOCS_URL: &str = "http://localhost:5173/reference/errors.html";
17
+
#[cfg(not(debug_assertions))]
18
+
const DOCS_URL: &str = "https://wire.althaea.zone/reference/errors.html";
19
+
20
+
#[derive(Debug, Diagnostic, Error)]
21
+
pub enum KeyError {
22
+
#[diagnostic(
23
+
code(wire::key::File),
24
+
url("{DOCS_URL}#{}", self.code().unwrap())
25
+
)]
26
+
#[error("error reading file")]
27
+
File(#[source] std::io::Error),
28
+
29
+
#[diagnostic(
30
+
code(wire::key::SpawningCommand),
31
+
help("Ensure wire has the correct $PATH for this command"),
32
+
url("{DOCS_URL}#{}", self.code().unwrap())
33
+
)]
34
+
#[error("error spawning key command")]
35
+
CommandSpawnError {
36
+
#[source]
37
+
error: std::io::Error,
38
+
39
+
#[source_code]
40
+
command: String,
41
+
42
+
#[label(primary, "Program ran")]
43
+
command_span: Option<SourceSpan>,
44
+
},
45
+
46
+
#[diagnostic(
47
+
code(wire::key::Resolving),
48
+
url("{DOCS_URL}#{}", self.code().unwrap())
49
+
)]
50
+
#[error("Error resolving key command child process")]
51
+
CommandResolveError {
52
+
#[source]
53
+
error: std::io::Error,
54
+
55
+
#[source_code]
56
+
command: String,
57
+
},
58
+
59
+
#[diagnostic(
60
+
code(wire::key::CommandExit),
61
+
url("{DOCS_URL}#{}", self.code().unwrap())
62
+
)]
63
+
#[error("key command failed with status {}: {}", .0,.1)]
64
+
CommandError(ExitStatus, String),
65
+
66
+
#[diagnostic(
67
+
code(wire::key::Empty),
68
+
url("{DOCS_URL}#{}", self.code().unwrap())
69
+
)]
70
+
#[error("Command list empty")]
71
+
Empty,
72
+
73
+
#[diagnostic(
74
+
code(wire::key::ParseKeyPermissions),
75
+
help("Refer to the documentation for the format of key file permissions."),
76
+
url("{DOCS_URL}#{}", self.code().unwrap())
77
+
)]
78
+
#[error("Failed to parse key permissions")]
79
+
ParseKeyPermissions(#[source] ParseIntError),
80
+
}
81
+
82
+
#[derive(Debug, Diagnostic, Error)]
83
+
pub enum ActivationError {
84
+
#[diagnostic(
85
+
code(wire::activation::SwitchToConfiguration),
86
+
url("{DOCS_URL}#{}", self.code().unwrap())
87
+
)]
88
+
#[error("failed to run switch-to-configuration {0} on node {1}")]
89
+
SwitchToConfigurationError(SwitchToConfigurationGoal, Name, #[source] CommandError),
90
+
}
91
+
92
+
#[derive(Debug, Diagnostic, Error)]
93
+
pub enum NetworkError {
94
+
#[diagnostic(
95
+
code(wire::network::HostUnreachable),
96
+
help(
97
+
"If you failed due to a fault in DNS, note that a node can have multiple targets defined."
98
+
),
99
+
url("{DOCS_URL}#{}", self.code().unwrap())
100
+
)]
101
+
#[error("Cannot reach host {host}")]
102
+
HostUnreachable {
103
+
host: String,
104
+
#[source]
105
+
source: CommandError,
106
+
},
107
+
108
+
#[diagnostic(
109
+
code(wire::network::HostUnreachableAfterReboot),
110
+
url("{DOCS_URL}#{}", self.code().unwrap())
111
+
)]
112
+
#[error("Failed to get regain connection to {0} after activation.")]
113
+
HostUnreachableAfterReboot(String),
114
+
115
+
#[diagnostic(
116
+
code(wire::network::HostsExhausted),
117
+
url("{DOCS_URL}#{}", self.code().unwrap())
118
+
)]
119
+
#[error("Ran out of contactable hosts")]
120
+
HostsExhausted,
121
+
}
122
+
123
+
#[derive(Debug, Diagnostic, Error)]
124
+
pub enum HiveInitialisationError {
125
+
#[diagnostic(
126
+
code(wire::hive_init::NoHiveFound),
127
+
help(
128
+
"Double check the path is correct. You can adjust the hive path with `--path` when the hive lies outside of the CWD."
129
+
),
130
+
url("{DOCS_URL}#{}", self.code().unwrap())
131
+
)]
132
+
#[error("No hive could be found in {}", .0.display())]
133
+
NoHiveFound(PathBuf),
134
+
135
+
#[diagnostic(
136
+
code(wire::hive_init::Parse),
137
+
help("If you cannot resolve this problem, please create an issue."),
138
+
url("{DOCS_URL}#{}", self.code().unwrap())
139
+
)]
140
+
#[error("Failed to parse internal wire json.")]
141
+
ParseEvaluateError(#[source] serde_json::Error),
142
+
143
+
#[diagnostic(
144
+
code(wire::hive_init::ParsePrefetch),
145
+
help("please create an issue."),
146
+
url("{DOCS_URL}#{}", self.code().unwrap())
147
+
)]
148
+
#[error("Failed to parse `nix flake prefetch --json`.")]
149
+
ParsePrefetchError(#[source] serde_json::Error),
150
+
151
+
#[diagnostic(
152
+
code(wire::hive_init::NodeDoesNotExist),
153
+
help("Please create an issue!"),
154
+
url("{DOCS_URL}#{}", self.code().unwrap())
155
+
)]
156
+
#[error("node {0} not exist in hive")]
157
+
NodeDoesNotExist(String),
158
+
}
159
+
160
+
#[derive(Debug, Diagnostic, Error)]
161
+
pub enum HiveLocationError {
162
+
#[diagnostic(
163
+
code(wire::hive_location::MalformedPath),
164
+
url("{DOCS_URL}#{}", self.code().unwrap())
165
+
)]
166
+
#[error("Path was malformed: {}", .0.display())]
167
+
MalformedPath(PathBuf),
168
+
169
+
#[diagnostic(
170
+
code(wire::hive_location::Malformed),
171
+
url("{DOCS_URL}#{}", self.code().unwrap())
172
+
)]
173
+
#[error("--path was malformed")]
174
+
Malformed(#[source] FlakeRefError),
175
+
176
+
#[diagnostic(
177
+
code(wire::hive_location::TypeUnsupported),
178
+
url("{DOCS_URL}#{}", self.code().unwrap())
179
+
)]
180
+
#[error("The flakref had an unsupported type: {:#?}", .0)]
181
+
TypeUnsupported(Box<FlakeRef>),
182
+
}
183
+
184
+
#[derive(Debug, Diagnostic, Error)]
185
+
pub enum CommandError {
186
+
#[diagnostic(
187
+
code(wire::command::TermAttrs),
188
+
url("{DOCS_URL}#{}", self.code().unwrap())
189
+
)]
190
+
#[error("Failed to set PTY attrs")]
191
+
TermAttrs(#[source] nix::errno::Errno),
192
+
193
+
#[diagnostic(
194
+
code(wire::command::PosixPipe),
195
+
url("{DOCS_URL}#{}", self.code().unwrap())
196
+
)]
197
+
#[error("There was an error in regards to a pipe")]
198
+
PosixPipe(#[source] nix::errno::Errno),
199
+
200
+
/// Error wrapped around `portable_pty`'s anyhow
201
+
/// errors
202
+
#[diagnostic(
203
+
code(wire::command::PortablePty),
204
+
url("{DOCS_URL}#{}", self.code().unwrap())
205
+
)]
206
+
#[error("There was an error from the portable_pty crate")]
207
+
PortablePty(#[source] anyhow::Error),
208
+
209
+
#[diagnostic(
210
+
code(wire::command::Joining),
211
+
url("{DOCS_URL}#{}", self.code().unwrap())
212
+
)]
213
+
#[error("Failed to join on some tokio task")]
214
+
JoinError(#[source] JoinError),
215
+
216
+
#[diagnostic(
217
+
code(wire::command::WaitForStatus),
218
+
url("{DOCS_URL}#{}", self.code().unwrap())
219
+
)]
220
+
#[error("Failed to wait for the child's status")]
221
+
WaitForStatus(#[source] std::io::Error),
222
+
223
+
#[diagnostic(
224
+
code(wire::detached::NoHandle),
225
+
help("This should never happen, please create an issue!"),
226
+
url("{DOCS_URL}#{}", self.code().unwrap())
227
+
)]
228
+
#[error("There was no handle to child io")]
229
+
NoHandle,
230
+
231
+
#[diagnostic(
232
+
code(wire::command::WritingClientStdout),
233
+
url("{DOCS_URL}#{}", self.code().unwrap())
234
+
)]
235
+
#[error("Failed to write to client stderr.")]
236
+
WritingClientStderr(#[source] std::io::Error),
237
+
238
+
#[diagnostic(
239
+
code(wire::command::WritingMasterStdin),
240
+
url("{DOCS_URL}#{}", self.code().unwrap())
241
+
)]
242
+
#[error("Failed to write to PTY master stdout.")]
243
+
WritingMasterStdout(#[source] std::io::Error),
244
+
245
+
#[diagnostic(
246
+
code(wire::command::Recv),
247
+
url("{DOCS_URL}#{}", self.code().unwrap()),
248
+
help("please create an issue!"),
249
+
)]
250
+
#[error("Failed to receive a message from the begin channel")]
251
+
RecvError(#[source] RecvError),
252
+
253
+
#[diagnostic(
254
+
code(wire::command::ThreadPanic),
255
+
url("{DOCS_URL}#{}", self.code().unwrap()),
256
+
help("please create an issue!"),
257
+
)]
258
+
#[error("Thread panicked")]
259
+
ThreadPanic,
260
+
261
+
#[diagnostic(
262
+
code(wire::command::CommandFailed),
263
+
url("{DOCS_URL}#{}", self.code().unwrap()),
264
+
help("`nix` commands are filtered, run with -vvv to view all"),
265
+
)]
266
+
#[error("{command_ran} failed ({reason}) with {code} (last 20 lines):\n{logs}")]
267
+
CommandFailed {
268
+
command_ran: String,
269
+
logs: String,
270
+
code: String,
271
+
reason: &'static str,
272
+
},
273
+
274
+
#[diagnostic(
275
+
code(wire::command::RuntimeDirectory),
276
+
url("{DOCS_URL}#{}", self.code().unwrap())
277
+
)]
278
+
#[error("error creating $XDG_RUNTIME_DIR/wire")]
279
+
RuntimeDirectory(#[source] std::io::Error),
280
+
281
+
#[diagnostic(
282
+
code(wire::command::RuntimeDirectoryMissing),
283
+
url("{DOCS_URL}#{}", self.code().unwrap())
284
+
)]
285
+
#[error("$XDG_RUNTIME_DIR could not be used.")]
286
+
RuntimeDirectoryMissing(#[source] std::env::VarError),
287
+
288
+
#[diagnostic(
289
+
code(wire::command::OneshotRecvError),
290
+
url("{DOCS_URL}#{}", self.code().unwrap())
291
+
)]
292
+
#[error("Error waiting for begin message")]
293
+
OneshotRecvError(#[source] tokio::sync::oneshot::error::RecvError),
294
+
}
295
+
296
+
#[derive(Debug, Diagnostic, Error)]
297
+
pub enum HiveLibError {
298
+
#[error(transparent)]
299
+
#[diagnostic(transparent)]
300
+
HiveInitialisationError(HiveInitialisationError),
301
+
302
+
#[error(transparent)]
303
+
#[diagnostic(transparent)]
304
+
NetworkError(NetworkError),
305
+
306
+
#[error(transparent)]
307
+
#[diagnostic(transparent)]
308
+
ActivationError(ActivationError),
309
+
310
+
#[error(transparent)]
311
+
#[diagnostic(transparent)]
312
+
CommandError(CommandError),
313
+
314
+
#[error(transparent)]
315
+
#[diagnostic(transparent)]
316
+
HiveLocationError(HiveLocationError),
317
+
318
+
#[error("Failed to apply key {}", .0)]
319
+
KeyError(
320
+
String,
321
+
#[source]
322
+
#[diagnostic_source]
323
+
KeyError,
324
+
),
325
+
326
+
#[diagnostic(
327
+
code(wire::BuildNode),
328
+
url("{DOCS_URL}#{}", self.code().unwrap())
329
+
)]
330
+
#[error("failed to build node {name}")]
331
+
NixBuildError {
332
+
name: Name,
333
+
#[source]
334
+
source: CommandError,
335
+
},
336
+
337
+
#[diagnostic(
338
+
code(wire::CopyPath),
339
+
url("{DOCS_URL}#{}", self.code().unwrap())
340
+
)]
341
+
#[error("failed to copy path {path} to node {name}")]
342
+
NixCopyError {
343
+
name: Name,
344
+
path: String,
345
+
#[source]
346
+
error: Box<CommandError>,
347
+
#[help]
348
+
help: Option<Box<String>>,
349
+
},
350
+
351
+
#[diagnostic(code(wire::Evaluate))]
352
+
#[error("failed to evaluate `{attribute}` from the context of a hive.")]
353
+
NixEvalError {
354
+
attribute: String,
355
+
356
+
#[source]
357
+
source: CommandError,
358
+
359
+
#[help]
360
+
help: Option<Box<String>>,
361
+
},
362
+
363
+
#[diagnostic(
364
+
code(wire::Encoding),
365
+
url("{DOCS_URL}#{}", self.code().unwrap())
366
+
)]
367
+
#[error("error encoding length delimited data")]
368
+
Encoding(#[source] std::io::Error),
369
+
370
+
#[diagnostic(
371
+
code(wire::SIGINT),
372
+
url("{DOCS_URL}#{}", self.code().unwrap())
373
+
)]
374
+
#[error("SIGINT received, shut down")]
375
+
Sigint,
376
+
}
+480
crates/core/src/hive/mod.rs
+480
crates/core/src/hive/mod.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use itertools::Itertools;
5
+
use nix_compat::flakeref::FlakeRef;
6
+
use node::{Name, Node};
7
+
use owo_colors::{OwoColorize, Stream};
8
+
use serde::de::Error;
9
+
use serde::{Deserialize, Deserializer, Serialize};
10
+
use std::collections::HashMap;
11
+
use std::collections::hash_map::OccupiedEntry;
12
+
use std::ffi::OsStr;
13
+
use std::fmt::Display;
14
+
use std::fs;
15
+
use std::path::PathBuf;
16
+
use std::str::FromStr;
17
+
use std::sync::Arc;
18
+
use tracing::{debug, info, instrument};
19
+
20
+
use crate::cache::InspectionCache;
21
+
use crate::commands::builder::CommandStringBuilder;
22
+
use crate::commands::common::evaluate_hive_attribute;
23
+
use crate::commands::{CommandArguments, Either, WireCommandChip, run_command};
24
+
use crate::errors::{HiveInitialisationError, HiveLocationError};
25
+
use crate::{EvalGoal, HiveLibError, SubCommandModifiers};
26
+
pub mod node;
27
+
pub mod steps;
28
+
29
+
#[derive(Serialize, Deserialize, Debug, PartialEq)]
30
+
#[serde(deny_unknown_fields)]
31
+
pub struct Hive {
32
+
pub nodes: HashMap<Name, Node>,
33
+
34
+
#[serde(deserialize_with = "check_schema_version", rename = "_schema")]
35
+
pub schema: u32,
36
+
}
37
+
38
+
pub enum Action<'a> {
39
+
Inspect,
40
+
EvaluateNode(OccupiedEntry<'a, String, Node>),
41
+
}
42
+
43
+
fn check_schema_version<'de, D: Deserializer<'de>>(d: D) -> Result<u32, D::Error> {
44
+
let version = u32::deserialize(d)?;
45
+
if version != Hive::SCHEMA_VERSION {
46
+
return Err(D::Error::custom(
47
+
"Version mismatch for Hive. Please ensure the binary and your wire input match!",
48
+
));
49
+
}
50
+
Ok(version)
51
+
}
52
+
53
+
impl Hive {
54
+
pub const SCHEMA_VERSION: u32 = 1;
55
+
56
+
#[instrument(skip_all, name = "eval_hive")]
57
+
pub async fn new_from_path(
58
+
location: &HiveLocation,
59
+
cache: Option<InspectionCache>,
60
+
modifiers: SubCommandModifiers,
61
+
) -> Result<Hive, HiveLibError> {
62
+
info!("evaluating hive {location:?}");
63
+
64
+
if let Some(ref cache) = cache
65
+
&& let HiveLocation::Flake { prefetch, .. } = location
66
+
&& let Some(hive) = cache.get_hive(prefetch).await
67
+
{
68
+
return Ok(hive);
69
+
}
70
+
71
+
let output = evaluate_hive_attribute(location, &EvalGoal::Inspect, modifiers).await?;
72
+
73
+
let hive: Hive = serde_json::from_str(&output).map_err(|err| {
74
+
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParseEvaluateError(err))
75
+
})?;
76
+
77
+
if let Some(cache) = cache
78
+
&& let HiveLocation::Flake { prefetch, .. } = location
79
+
{
80
+
cache.store_hive(prefetch, &output).await;
81
+
}
82
+
83
+
Ok(hive)
84
+
}
85
+
86
+
/// # Errors
87
+
///
88
+
/// Returns an error if a node in nodes does not exist in the hive.
89
+
pub fn force_always_local(&mut self, nodes: Vec<String>) -> Result<(), HiveLibError> {
90
+
for node in nodes {
91
+
info!("Forcing a local build for {node}");
92
+
93
+
self.nodes
94
+
.get_mut(&Name(Arc::from(node.clone())))
95
+
.ok_or(HiveLibError::HiveInitialisationError(
96
+
HiveInitialisationError::NodeDoesNotExist(node.clone()),
97
+
))?
98
+
.build_remotely = false;
99
+
}
100
+
101
+
Ok(())
102
+
}
103
+
}
104
+
105
+
impl Display for Hive {
106
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
107
+
for (name, node) in &self.nodes {
108
+
writeln!(
109
+
f,
110
+
"Node {} {}:\n",
111
+
name.bold(),
112
+
format!("({})", node.host_platform)
113
+
.italic()
114
+
.if_supports_color(Stream::Stdout, |x| x.dimmed()),
115
+
)?;
116
+
117
+
if !node.tags.is_empty() {
118
+
write!(f, " > {}", "Tags:".bold())?;
119
+
writeln!(f, " {:?}", node.tags)?;
120
+
}
121
+
122
+
write!(f, " > {}", "Connection:".bold())?;
123
+
writeln!(f, " {{{}}}", node.target)?;
124
+
125
+
write!(
126
+
f,
127
+
" > {} {}{}",
128
+
"Build remotely".bold(),
129
+
"`deployment.buildOnTarget`"
130
+
.if_supports_color(Stream::Stdout, |x| x.dimmed())
131
+
.italic(),
132
+
":".bold()
133
+
)?;
134
+
writeln!(f, " {}", node.build_remotely)?;
135
+
136
+
write!(
137
+
f,
138
+
" > {} {}{}",
139
+
"Local apply allowed".bold(),
140
+
"`deployment.allowLocalDeployment`"
141
+
.if_supports_color(Stream::Stdout, |x| x.dimmed())
142
+
.italic(),
143
+
":".bold()
144
+
)?;
145
+
writeln!(f, " {}", node.allow_local_deployment)?;
146
+
147
+
if !node.keys.is_empty() {
148
+
write!(f, " > {}", "Keys:".bold())?;
149
+
writeln!(f, " {} key(s)", node.keys.len())?;
150
+
151
+
for key in &node.keys {
152
+
writeln!(f, " > {key}")?;
153
+
}
154
+
}
155
+
156
+
writeln!(f)?;
157
+
}
158
+
159
+
let total_keys = self
160
+
.nodes
161
+
.values()
162
+
.flat_map(|node| node.keys.iter())
163
+
.collect::<Vec<_>>();
164
+
let distinct_keys = self
165
+
.nodes
166
+
.values()
167
+
.flat_map(|node| node.keys.iter())
168
+
.unique()
169
+
.collect::<Vec<_>>()
170
+
.len();
171
+
172
+
write!(f, "{}", "Summary:".bold())?;
173
+
writeln!(
174
+
f,
175
+
" {} total node(s), totalling {} keys ({distinct_keys} distinct).",
176
+
self.nodes.len(),
177
+
total_keys.len()
178
+
)?;
179
+
writeln!(
180
+
f,
181
+
"{}",
182
+
"Note: Listed connections are tried from Left to Right".italic(),
183
+
)?;
184
+
185
+
Ok(())
186
+
}
187
+
}
188
+
189
+
#[derive(Debug, PartialEq, Eq, Deserialize)]
190
+
pub struct FlakePrefetch {
191
+
pub(crate) hash: String,
192
+
#[serde(rename = "storePath")]
193
+
pub(crate) store_path: String,
194
+
}
195
+
196
+
#[derive(Debug, PartialEq, Eq)]
197
+
pub enum HiveLocation {
198
+
HiveNix(PathBuf),
199
+
Flake {
200
+
uri: String,
201
+
prefetch: FlakePrefetch,
202
+
},
203
+
}
204
+
205
+
impl HiveLocation {
206
+
async fn get_flake(
207
+
uri: String,
208
+
modifiers: SubCommandModifiers,
209
+
) -> Result<HiveLocation, HiveLibError> {
210
+
let mut command_string = CommandStringBuilder::nix();
211
+
command_string.args(&[
212
+
"flake",
213
+
"prefetch",
214
+
"--extra-experimental-features",
215
+
"nix-command",
216
+
"--extra-experimental-features",
217
+
"flakes",
218
+
"--json",
219
+
]);
220
+
command_string.arg(&uri);
221
+
222
+
let command = run_command(
223
+
&CommandArguments::new(command_string, modifiers)
224
+
.mode(crate::commands::ChildOutputMode::Generic),
225
+
)
226
+
.await?;
227
+
228
+
let result = command
229
+
.wait_till_success()
230
+
.await
231
+
.map_err(HiveLibError::CommandError)?;
232
+
233
+
debug!(hash_json = ?result);
234
+
235
+
let prefetch = serde_json::from_str(&match result {
236
+
Either::Left((.., output)) | Either::Right((.., output)) => output,
237
+
})
238
+
.map_err(|x| {
239
+
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParsePrefetchError(x))
240
+
})?;
241
+
242
+
debug!(prefetch = ?prefetch);
243
+
244
+
Ok(HiveLocation::Flake { uri, prefetch })
245
+
}
246
+
}
247
+
248
+
pub async fn get_hive_location(
249
+
path: String,
250
+
modifiers: SubCommandModifiers,
251
+
) -> Result<HiveLocation, HiveLibError> {
252
+
let flakeref = FlakeRef::from_str(&path);
253
+
254
+
let path_to_location = async |path: PathBuf| {
255
+
Ok(match path.file_name().and_then(OsStr::to_str) {
256
+
Some("hive.nix") => HiveLocation::HiveNix(path.clone()),
257
+
Some(_) => {
258
+
if fs::metadata(path.join("flake.nix")).is_ok() {
259
+
HiveLocation::get_flake(path.display().to_string(), modifiers).await?
260
+
} else {
261
+
HiveLocation::HiveNix(path.join("hive.nix"))
262
+
}
263
+
}
264
+
None => {
265
+
return Err(HiveLibError::HiveLocationError(
266
+
HiveLocationError::MalformedPath(path.clone()),
267
+
));
268
+
}
269
+
})
270
+
};
271
+
272
+
match flakeref {
273
+
Err(nix_compat::flakeref::FlakeRefError::UrlParseError(_err)) => {
274
+
let path = PathBuf::from(path);
275
+
Ok(path_to_location(path).await?)
276
+
}
277
+
Ok(FlakeRef::Path { path, .. }) => Ok(path_to_location(path).await?),
278
+
Ok(
279
+
FlakeRef::Git { .. }
280
+
| FlakeRef::GitHub { .. }
281
+
| FlakeRef::GitLab { .. }
282
+
| FlakeRef::Tarball { .. }
283
+
| FlakeRef::Mercurial { .. }
284
+
| FlakeRef::SourceHut { .. },
285
+
) => Ok(HiveLocation::get_flake(path, modifiers).await?),
286
+
Err(err) => Err(HiveLibError::HiveLocationError(
287
+
HiveLocationError::Malformed(err),
288
+
)),
289
+
Ok(flakeref) => Err(HiveLibError::HiveLocationError(
290
+
HiveLocationError::TypeUnsupported(Box::new(flakeref)),
291
+
)),
292
+
}
293
+
}
294
+
295
+
#[cfg(test)]
296
+
mod tests {
297
+
use im::vector;
298
+
299
+
use crate::{
300
+
errors::CommandError,
301
+
get_test_path,
302
+
hive::steps::keys::{Key, Source, UploadKeyAt},
303
+
location,
304
+
test_support::make_flake_sandbox,
305
+
};
306
+
307
+
use super::*;
308
+
use std::{assert_matches::assert_matches, env};
309
+
310
+
// flake should always come before hive.nix
311
+
#[tokio::test]
312
+
async fn test_hive_dot_nix_priority() {
313
+
let location = location!(get_test_path!());
314
+
315
+
assert_matches!(location, HiveLocation::Flake { .. });
316
+
}
317
+
318
+
#[tokio::test]
319
+
#[cfg_attr(feature = "no_web_tests", ignore)]
320
+
async fn test_hive_file() {
321
+
let location = location!(get_test_path!());
322
+
323
+
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
324
+
.await
325
+
.unwrap();
326
+
327
+
let node = Node {
328
+
target: node::Target::from_host("192.168.122.96"),
329
+
..Default::default()
330
+
};
331
+
332
+
let mut nodes = HashMap::new();
333
+
nodes.insert(Name("node-a".into()), node);
334
+
335
+
assert_eq!(
336
+
hive,
337
+
Hive {
338
+
nodes,
339
+
schema: Hive::SCHEMA_VERSION
340
+
}
341
+
);
342
+
}
343
+
344
+
#[tokio::test]
345
+
#[cfg_attr(feature = "no_web_tests", ignore)]
346
+
async fn non_trivial_hive() {
347
+
let location = location!(get_test_path!());
348
+
349
+
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
350
+
.await
351
+
.unwrap();
352
+
353
+
let node = Node {
354
+
target: node::Target::from_host("name"),
355
+
keys: vector![Key {
356
+
name: "different-than-a".into(),
357
+
dest_dir: "/run/keys/".into(),
358
+
path: "/run/keys/different-than-a".into(),
359
+
group: "root".into(),
360
+
user: "root".into(),
361
+
permissions: "0600".into(),
362
+
source: Source::String("hi".into()),
363
+
upload_at: UploadKeyAt::PreActivation,
364
+
environment: im::HashMap::new()
365
+
}],
366
+
build_remotely: true,
367
+
..Default::default()
368
+
};
369
+
370
+
let mut nodes = HashMap::new();
371
+
nodes.insert(Name("node-a".into()), node);
372
+
373
+
assert_eq!(
374
+
hive,
375
+
Hive {
376
+
nodes,
377
+
schema: Hive::SCHEMA_VERSION
378
+
}
379
+
);
380
+
}
381
+
382
+
#[tokio::test]
383
+
#[cfg_attr(feature = "no_web_tests", ignore)]
384
+
async fn flake_hive() {
385
+
let tmp_dir = make_flake_sandbox(&get_test_path!()).unwrap();
386
+
387
+
let location = get_hive_location(
388
+
tmp_dir.path().display().to_string(),
389
+
SubCommandModifiers::default(),
390
+
)
391
+
.await
392
+
.unwrap();
393
+
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
394
+
.await
395
+
.unwrap();
396
+
397
+
let mut nodes = HashMap::new();
398
+
399
+
// a merged node
400
+
nodes.insert(Name("node-a".into()), Node::from_host("node-a"));
401
+
// a non-merged node
402
+
nodes.insert(Name("node-b".into()), Node::from_host("node-b"));
403
+
404
+
assert_eq!(
405
+
hive,
406
+
Hive {
407
+
nodes,
408
+
schema: Hive::SCHEMA_VERSION
409
+
}
410
+
);
411
+
412
+
tmp_dir.close().unwrap();
413
+
}
414
+
415
+
#[tokio::test]
416
+
async fn no_nixpkgs() {
417
+
let location = location!(get_test_path!());
418
+
419
+
assert_matches!(
420
+
Hive::new_from_path(&location, None, SubCommandModifiers::default()).await,
421
+
Err(HiveLibError::NixEvalError {
422
+
source: CommandError::CommandFailed {
423
+
logs,
424
+
..
425
+
},
426
+
..
427
+
})
428
+
if logs.contains("makeHive called without meta.nixpkgs specified")
429
+
);
430
+
}
431
+
432
+
#[tokio::test]
433
+
async fn _keys_should_fail() {
434
+
let location = location!(get_test_path!());
435
+
436
+
assert_matches!(
437
+
Hive::new_from_path(&location, None, SubCommandModifiers::default()).await,
438
+
Err(HiveLibError::NixEvalError {
439
+
source: CommandError::CommandFailed {
440
+
logs,
441
+
..
442
+
},
443
+
..
444
+
})
445
+
if logs.contains("The option `deployment._keys' is read-only, but it's set multiple times.")
446
+
);
447
+
}
448
+
449
+
#[tokio::test]
450
+
async fn test_force_always_local() {
451
+
let mut location: PathBuf = env::var("WIRE_TEST_DIR").unwrap().into();
452
+
location.push("non_trivial_hive");
453
+
let location = location!(location);
454
+
455
+
let mut hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
456
+
.await
457
+
.unwrap();
458
+
459
+
assert_matches!(
460
+
hive.force_always_local(vec!["non-existent".to_string()]),
461
+
Err(HiveLibError::HiveInitialisationError(
462
+
HiveInitialisationError::NodeDoesNotExist(node)
463
+
)) if node == "non-existent"
464
+
);
465
+
466
+
for node in hive.nodes.values() {
467
+
assert!(node.build_remotely);
468
+
}
469
+
470
+
assert_matches!(hive.force_always_local(vec!["node-a".to_string()]), Ok(()));
471
+
472
+
assert!(
473
+
!hive
474
+
.nodes
475
+
.get(&Name("node-a".into()))
476
+
.unwrap()
477
+
.build_remotely
478
+
);
479
+
}
480
+
}
+939
crates/core/src/hive/node.rs
+939
crates/core/src/hive/node.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#![allow(clippy::missing_errors_doc)]
5
+
use enum_dispatch::enum_dispatch;
6
+
use gethostname::gethostname;
7
+
use serde::{Deserialize, Serialize};
8
+
use std::assert_matches::debug_assert_matches;
9
+
use std::fmt::Display;
10
+
use std::sync::Arc;
11
+
use std::sync::atomic::AtomicBool;
12
+
use tokio::sync::oneshot;
13
+
use tracing::{Instrument, Level, Span, debug, error, event, instrument, trace};
14
+
15
+
use crate::commands::builder::CommandStringBuilder;
16
+
use crate::commands::common::evaluate_hive_attribute;
17
+
use crate::commands::{CommandArguments, WireCommandChip, run_command};
18
+
use crate::errors::NetworkError;
19
+
use crate::hive::HiveLocation;
20
+
use crate::hive::steps::build::Build;
21
+
use crate::hive::steps::cleanup::CleanUp;
22
+
use crate::hive::steps::evaluate::Evaluate;
23
+
use crate::hive::steps::keys::{Key, Keys, PushKeyAgent, UploadKeyAt};
24
+
use crate::hive::steps::ping::Ping;
25
+
use crate::hive::steps::push::{PushBuildOutput, PushEvaluatedOutput};
26
+
use crate::status::STATUS;
27
+
use crate::{EvalGoal, StrictHostKeyChecking, SubCommandModifiers};
28
+
29
+
use super::HiveLibError;
30
+
use super::steps::activate::SwitchToConfiguration;
31
+
32
+
#[derive(
33
+
Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord, derive_more::Display,
34
+
)]
35
+
pub struct Name(pub Arc<str>);
36
+
37
+
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
38
+
pub struct Target {
39
+
pub hosts: Vec<Arc<str>>,
40
+
pub user: Arc<str>,
41
+
pub port: u32,
42
+
43
+
#[serde(skip)]
44
+
current_host: usize,
45
+
}
46
+
47
+
impl Target {
48
+
#[instrument(ret(level = tracing::Level::DEBUG), skip_all)]
49
+
pub fn create_ssh_opts(
50
+
&self,
51
+
modifiers: SubCommandModifiers,
52
+
master: bool,
53
+
) -> Result<String, HiveLibError> {
54
+
self.create_ssh_args(modifiers, false, master)
55
+
.map(|x| x.join(" "))
56
+
}
57
+
58
+
#[instrument(ret(level = tracing::Level::DEBUG))]
59
+
pub fn create_ssh_args(
60
+
&self,
61
+
modifiers: SubCommandModifiers,
62
+
non_interactive_forced: bool,
63
+
master: bool,
64
+
) -> Result<Vec<String>, HiveLibError> {
65
+
let mut vector = vec![
66
+
"-l".to_string(),
67
+
self.user.to_string(),
68
+
"-p".to_string(),
69
+
self.port.to_string(),
70
+
];
71
+
let mut options = vec![
72
+
format!(
73
+
"StrictHostKeyChecking={}",
74
+
match modifiers.ssh_accept_host {
75
+
StrictHostKeyChecking::AcceptNew => "accept-new",
76
+
StrictHostKeyChecking::No => "no",
77
+
}
78
+
)
79
+
.to_string(),
80
+
];
81
+
82
+
options.extend(["PasswordAuthentication=no".to_string()]);
83
+
options.extend(["KbdInteractiveAuthentication=no".to_string()]);
84
+
85
+
vector.push("-o".to_string());
86
+
vector.extend(options.into_iter().intersperse("-o".to_string()));
87
+
88
+
Ok(vector)
89
+
}
90
+
}
91
+
92
+
#[cfg(test)]
93
+
impl Default for Target {
94
+
fn default() -> Self {
95
+
Target {
96
+
hosts: vec!["NAME".into()],
97
+
user: "root".into(),
98
+
port: 22,
99
+
current_host: 0,
100
+
}
101
+
}
102
+
}
103
+
104
+
#[cfg(test)]
105
+
impl<'a> Context<'a> {
106
+
fn create_test_context(
107
+
hive_location: HiveLocation,
108
+
name: &'a Name,
109
+
node: &'a mut Node,
110
+
) -> Self {
111
+
Context {
112
+
name,
113
+
node,
114
+
hive_location: Arc::new(hive_location),
115
+
modifiers: SubCommandModifiers::default(),
116
+
objective: Objective::Apply(ApplyObjective {
117
+
goal: Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch),
118
+
no_keys: false,
119
+
reboot: false,
120
+
should_apply_locally: false,
121
+
substitute_on_destination: false,
122
+
handle_unreachable: HandleUnreachable::default(),
123
+
}),
124
+
state: StepState::default(),
125
+
should_quit: Arc::new(AtomicBool::new(false)),
126
+
}
127
+
}
128
+
}
129
+
130
+
impl Target {
131
+
pub fn get_preferred_host(&self) -> Result<&Arc<str>, HiveLibError> {
132
+
self.hosts
133
+
.get(self.current_host)
134
+
.ok_or(HiveLibError::NetworkError(NetworkError::HostsExhausted))
135
+
}
136
+
137
+
pub const fn host_failed(&mut self) {
138
+
self.current_host += 1;
139
+
}
140
+
141
+
#[cfg(test)]
142
+
#[must_use]
143
+
pub fn from_host(host: &str) -> Self {
144
+
Target {
145
+
hosts: vec![host.into()],
146
+
..Default::default()
147
+
}
148
+
}
149
+
}
150
+
151
+
impl Display for Target {
152
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
153
+
let hosts = itertools::Itertools::join(
154
+
&mut self
155
+
.hosts
156
+
.iter()
157
+
.map(|host| format!("{}@{host}:{}", self.user, self.port)),
158
+
", ",
159
+
);
160
+
161
+
write!(f, "{hosts}")
162
+
}
163
+
}
164
+
165
+
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
166
+
pub struct Node {
167
+
#[serde(rename = "target")]
168
+
pub target: Target,
169
+
170
+
#[serde(rename = "buildOnTarget")]
171
+
pub build_remotely: bool,
172
+
173
+
#[serde(rename = "allowLocalDeployment")]
174
+
pub allow_local_deployment: bool,
175
+
176
+
#[serde(default)]
177
+
pub tags: im::HashSet<String>,
178
+
179
+
#[serde(rename(deserialize = "_keys", serialize = "keys"))]
180
+
pub keys: im::Vector<Key>,
181
+
182
+
#[serde(rename(deserialize = "_hostPlatform", serialize = "host_platform"))]
183
+
pub host_platform: Arc<str>,
184
+
185
+
#[serde(rename(
186
+
deserialize = "privilegeEscalationCommand",
187
+
serialize = "privilege_escalation_command"
188
+
))]
189
+
pub privilege_escalation_command: im::Vector<Arc<str>>,
190
+
}
191
+
192
+
#[cfg(test)]
193
+
impl Default for Node {
194
+
fn default() -> Self {
195
+
Node {
196
+
target: Target::default(),
197
+
keys: im::Vector::new(),
198
+
tags: im::HashSet::new(),
199
+
privilege_escalation_command: vec!["sudo".into(), "--".into()].into(),
200
+
allow_local_deployment: true,
201
+
build_remotely: false,
202
+
host_platform: "x86_64-linux".into(),
203
+
}
204
+
}
205
+
}
206
+
207
+
impl Node {
208
+
#[cfg(test)]
209
+
#[must_use]
210
+
pub fn from_host(host: &str) -> Self {
211
+
Node {
212
+
target: Target::from_host(host),
213
+
..Default::default()
214
+
}
215
+
}
216
+
217
+
/// Tests the connection to a node
218
+
pub async fn ping(&self, modifiers: SubCommandModifiers) -> Result<(), HiveLibError> {
219
+
let host = self.target.get_preferred_host()?;
220
+
221
+
let mut command_string = CommandStringBuilder::new("ssh");
222
+
command_string.arg(format!("{}@{host}", self.target.user));
223
+
command_string.arg(self.target.create_ssh_opts(modifiers, true)?);
224
+
command_string.arg("exit");
225
+
226
+
let output = run_command(
227
+
&CommandArguments::new(command_string, modifiers)
228
+
.log_stdout()
229
+
.mode(crate::commands::ChildOutputMode::Interactive),
230
+
)
231
+
.await?;
232
+
233
+
output.wait_till_success().await.map_err(|source| {
234
+
HiveLibError::NetworkError(NetworkError::HostUnreachable {
235
+
host: host.to_string(),
236
+
source,
237
+
})
238
+
})?;
239
+
240
+
Ok(())
241
+
}
242
+
}
243
+
244
+
#[must_use]
245
+
pub fn should_apply_locally(allow_local_deployment: bool, name: &str) -> bool {
246
+
*name == *gethostname() && allow_local_deployment
247
+
}
248
+
249
+
#[derive(derive_more::Display)]
250
+
pub enum Push<'a> {
251
+
Derivation(&'a Derivation),
252
+
Path(&'a String),
253
+
}
254
+
255
+
#[derive(Deserialize, Clone, Debug)]
256
+
pub struct Derivation(String);
257
+
258
+
impl Display for Derivation {
259
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
260
+
self.0.fmt(f).and_then(|()| write!(f, "^*"))
261
+
}
262
+
}
263
+
264
+
#[derive(derive_more::Display, Debug, Clone, Copy)]
265
+
pub enum SwitchToConfigurationGoal {
266
+
Switch,
267
+
Boot,
268
+
Test,
269
+
DryActivate,
270
+
}
271
+
272
+
#[derive(derive_more::Display, Clone, Copy)]
273
+
pub enum Goal {
274
+
SwitchToConfiguration(SwitchToConfigurationGoal),
275
+
Build,
276
+
Push,
277
+
Keys,
278
+
}
279
+
280
+
// TODO: Get rid of this allow and resolve it
281
+
#[allow(clippy::struct_excessive_bools)]
282
+
#[derive(Clone, Copy)]
283
+
pub struct ApplyObjective {
284
+
pub goal: Goal,
285
+
pub no_keys: bool,
286
+
pub reboot: bool,
287
+
pub should_apply_locally: bool,
288
+
pub substitute_on_destination: bool,
289
+
pub handle_unreachable: HandleUnreachable,
290
+
}
291
+
292
+
#[derive(Clone, Copy)]
293
+
pub enum Objective {
294
+
Apply(ApplyObjective),
295
+
BuildLocally,
296
+
}
297
+
298
+
#[enum_dispatch]
299
+
pub(crate) trait ExecuteStep: Send + Sync + Display + std::fmt::Debug {
300
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError>;
301
+
302
+
fn should_execute(&self, context: &Context) -> bool;
303
+
}
304
+
305
+
// may include other options such as FailAll in the future
306
+
#[non_exhaustive]
307
+
#[derive(Clone, Copy, Default)]
308
+
pub enum HandleUnreachable {
309
+
Ignore,
310
+
#[default]
311
+
FailNode,
312
+
}
313
+
314
+
#[derive(Default)]
315
+
pub struct StepState {
316
+
pub evaluation: Option<Derivation>,
317
+
pub evaluation_rx: Option<oneshot::Receiver<Result<Derivation, HiveLibError>>>,
318
+
pub build: Option<String>,
319
+
pub key_agent_directory: Option<String>,
320
+
}
321
+
322
+
pub struct Context<'a> {
323
+
pub name: &'a Name,
324
+
pub node: &'a mut Node,
325
+
pub hive_location: Arc<HiveLocation>,
326
+
pub modifiers: SubCommandModifiers,
327
+
pub state: StepState,
328
+
pub should_quit: Arc<AtomicBool>,
329
+
pub objective: Objective,
330
+
}
331
+
332
+
#[enum_dispatch(ExecuteStep)]
333
+
#[derive(Debug, PartialEq)]
334
+
enum Step {
335
+
Ping,
336
+
PushKeyAgent,
337
+
Keys,
338
+
Evaluate,
339
+
PushEvaluatedOutput,
340
+
Build,
341
+
PushBuildOutput,
342
+
SwitchToConfiguration,
343
+
CleanUp,
344
+
}
345
+
346
+
impl Display for Step {
347
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
348
+
match self {
349
+
Self::Ping(step) => step.fmt(f),
350
+
Self::PushKeyAgent(step) => step.fmt(f),
351
+
Self::Keys(step) => step.fmt(f),
352
+
Self::Evaluate(step) => step.fmt(f),
353
+
Self::PushEvaluatedOutput(step) => step.fmt(f),
354
+
Self::Build(step) => step.fmt(f),
355
+
Self::PushBuildOutput(step) => step.fmt(f),
356
+
Self::SwitchToConfiguration(step) => step.fmt(f),
357
+
Self::CleanUp(step) => step.fmt(f),
358
+
}
359
+
}
360
+
}
361
+
362
+
pub struct GoalExecutor<'a> {
363
+
steps: Vec<Step>,
364
+
context: Context<'a>,
365
+
}
366
+
367
+
/// returns Err if the application should shut down.
368
+
fn app_shutdown_guard(context: &Context) -> Result<(), HiveLibError> {
369
+
if context
370
+
.should_quit
371
+
.load(std::sync::atomic::Ordering::Relaxed)
372
+
{
373
+
return Err(HiveLibError::Sigint);
374
+
}
375
+
376
+
Ok(())
377
+
}
378
+
379
+
impl<'a> GoalExecutor<'a> {
380
+
#[must_use]
381
+
pub fn new(context: Context<'a>) -> Self {
382
+
Self {
383
+
steps: vec![
384
+
Step::Ping(Ping),
385
+
Step::PushKeyAgent(PushKeyAgent),
386
+
Step::Keys(Keys {
387
+
filter: UploadKeyAt::NoFilter,
388
+
}),
389
+
Step::Keys(Keys {
390
+
filter: UploadKeyAt::PreActivation,
391
+
}),
392
+
Step::Evaluate(super::steps::evaluate::Evaluate),
393
+
Step::PushEvaluatedOutput(super::steps::push::PushEvaluatedOutput),
394
+
Step::Build(super::steps::build::Build),
395
+
Step::PushBuildOutput(super::steps::push::PushBuildOutput),
396
+
Step::SwitchToConfiguration(SwitchToConfiguration),
397
+
Step::Keys(Keys {
398
+
filter: UploadKeyAt::PostActivation,
399
+
}),
400
+
],
401
+
context,
402
+
}
403
+
}
404
+
405
+
#[instrument(skip_all, name = "eval")]
406
+
async fn evaluate_task(
407
+
tx: oneshot::Sender<Result<Derivation, HiveLibError>>,
408
+
hive_location: Arc<HiveLocation>,
409
+
name: Name,
410
+
modifiers: SubCommandModifiers,
411
+
) {
412
+
let output =
413
+
evaluate_hive_attribute(&hive_location, &EvalGoal::GetTopLevel(&name), modifiers)
414
+
.await
415
+
.map(|output| {
416
+
serde_json::from_str::<Derivation>(&output).expect("failed to parse derivation")
417
+
});
418
+
419
+
debug!(output = ?output, done = true);
420
+
421
+
let _ = tx.send(output);
422
+
}
423
+
424
+
#[instrument(skip_all, fields(node = %self.context.name))]
425
+
pub async fn execute(mut self) -> Result<(), HiveLibError> {
426
+
app_shutdown_guard(&self.context)?;
427
+
428
+
let (tx, rx) = oneshot::channel();
429
+
self.context.state.evaluation_rx = Some(rx);
430
+
431
+
// The name of this span should never be changed without updating
432
+
// `wire/cli/tracing_setup.rs`
433
+
debug_assert_matches!(Span::current().metadata().unwrap().name(), "execute");
434
+
// This span should always have a `node` field by the same file
435
+
debug_assert!(
436
+
Span::current()
437
+
.metadata()
438
+
.unwrap()
439
+
.fields()
440
+
.field("node")
441
+
.is_some()
442
+
);
443
+
444
+
let spawn_evaluator = match self.context.objective {
445
+
Objective::Apply(apply_objective) => !matches!(apply_objective.goal, Goal::Keys),
446
+
Objective::BuildLocally => true,
447
+
};
448
+
449
+
if spawn_evaluator {
450
+
tokio::spawn(
451
+
GoalExecutor::evaluate_task(
452
+
tx,
453
+
self.context.hive_location.clone(),
454
+
self.context.name.clone(),
455
+
self.context.modifiers,
456
+
)
457
+
.in_current_span(),
458
+
);
459
+
}
460
+
461
+
let steps = self
462
+
.steps
463
+
.iter()
464
+
.filter(|step| step.should_execute(&self.context))
465
+
.inspect(|step| {
466
+
trace!("Will execute step `{step}` for {}", self.context.name);
467
+
})
468
+
.collect::<Vec<_>>();
469
+
let length = steps.len();
470
+
471
+
for (position, step) in steps.iter().enumerate() {
472
+
app_shutdown_guard(&self.context)?;
473
+
474
+
event!(
475
+
Level::INFO,
476
+
step = step.to_string(),
477
+
progress = format!("{}/{length}", position + 1)
478
+
);
479
+
480
+
STATUS
481
+
.lock()
482
+
.set_node_step(self.context.name, step.to_string());
483
+
484
+
if let Err(err) = step.execute(&mut self.context).await.inspect_err(|_| {
485
+
error!("Failed to execute `{step}`");
486
+
}) {
487
+
// discard error from cleanup
488
+
let _ = CleanUp.execute(&mut self.context).await;
489
+
490
+
if let Objective::Apply(apply_objective) = self.context.objective
491
+
&& matches!(step, Step::Ping(..))
492
+
&& matches!(
493
+
apply_objective.handle_unreachable,
494
+
HandleUnreachable::Ignore,
495
+
)
496
+
{
497
+
return Ok(());
498
+
}
499
+
500
+
STATUS.lock().mark_node_failed(self.context.name);
501
+
502
+
return Err(err);
503
+
}
504
+
}
505
+
506
+
STATUS.lock().mark_node_succeeded(self.context.name);
507
+
508
+
Ok(())
509
+
}
510
+
}
511
+
512
+
#[cfg(test)]
513
+
mod tests {
514
+
use rand::distr::Alphabetic;
515
+
516
+
use super::*;
517
+
use crate::{
518
+
function_name, get_test_path,
519
+
hive::{Hive, get_hive_location},
520
+
location,
521
+
};
522
+
use std::{assert_matches::assert_matches, path::PathBuf};
523
+
use std::{collections::HashMap, env};
524
+
525
+
fn get_steps(goal_executor: GoalExecutor) -> std::vec::Vec<Step> {
526
+
goal_executor
527
+
.steps
528
+
.into_iter()
529
+
.filter(|step| step.should_execute(&goal_executor.context))
530
+
.collect::<Vec<_>>()
531
+
}
532
+
533
+
#[tokio::test]
534
+
#[cfg_attr(feature = "no_web_tests", ignore)]
535
+
async fn default_values_match() {
536
+
let mut path = get_test_path!();
537
+
538
+
let location =
539
+
get_hive_location(path.display().to_string(), SubCommandModifiers::default())
540
+
.await
541
+
.unwrap();
542
+
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
543
+
.await
544
+
.unwrap();
545
+
546
+
let node = Node::default();
547
+
548
+
let mut nodes = HashMap::new();
549
+
nodes.insert(Name("NAME".into()), node);
550
+
551
+
path.push("hive.nix");
552
+
553
+
assert_eq!(
554
+
hive,
555
+
Hive {
556
+
nodes,
557
+
schema: Hive::SCHEMA_VERSION
558
+
}
559
+
);
560
+
}
561
+
562
+
#[tokio::test]
563
+
async fn order_build_locally() {
564
+
let location = location!(get_test_path!());
565
+
let mut node = Node {
566
+
build_remotely: false,
567
+
..Default::default()
568
+
};
569
+
let name = &Name(function_name!().into());
570
+
let executor = GoalExecutor::new(Context::create_test_context(location, name, &mut node));
571
+
let steps = get_steps(executor);
572
+
573
+
assert_eq!(
574
+
steps,
575
+
vec![
576
+
Ping.into(),
577
+
PushKeyAgent.into(),
578
+
Keys {
579
+
filter: UploadKeyAt::PreActivation
580
+
}
581
+
.into(),
582
+
crate::hive::steps::evaluate::Evaluate.into(),
583
+
crate::hive::steps::build::Build.into(),
584
+
crate::hive::steps::push::PushBuildOutput.into(),
585
+
SwitchToConfiguration.into(),
586
+
Keys {
587
+
filter: UploadKeyAt::PostActivation
588
+
}
589
+
.into(),
590
+
]
591
+
);
592
+
}
593
+
594
+
#[tokio::test]
595
+
async fn order_keys_only() {
596
+
let location = location!(get_test_path!());
597
+
let mut node = Node::default();
598
+
let name = &Name(function_name!().into());
599
+
let mut context = Context::create_test_context(location, name, &mut node);
600
+
601
+
let Objective::Apply(ref mut apply_objective) = context.objective else {
602
+
unreachable!()
603
+
};
604
+
605
+
apply_objective.goal = Goal::Keys;
606
+
607
+
let executor = GoalExecutor::new(context);
608
+
let steps = get_steps(executor);
609
+
610
+
assert_eq!(
611
+
steps,
612
+
vec![
613
+
Ping.into(),
614
+
PushKeyAgent.into(),
615
+
Keys {
616
+
filter: UploadKeyAt::NoFilter
617
+
}
618
+
.into(),
619
+
]
620
+
);
621
+
}
622
+
623
+
#[tokio::test]
624
+
async fn order_build() {
625
+
let location = location!(get_test_path!());
626
+
let mut node = Node::default();
627
+
let name = &Name(function_name!().into());
628
+
let mut context = Context::create_test_context(location, name, &mut node);
629
+
630
+
let Objective::Apply(ref mut apply_objective) = context.objective else {
631
+
unreachable!()
632
+
};
633
+
apply_objective.goal = Goal::Build;
634
+
635
+
let executor = GoalExecutor::new(context);
636
+
let steps = get_steps(executor);
637
+
638
+
assert_eq!(
639
+
steps,
640
+
vec![
641
+
Ping.into(),
642
+
crate::hive::steps::evaluate::Evaluate.into(),
643
+
crate::hive::steps::build::Build.into(),
644
+
crate::hive::steps::push::PushBuildOutput.into(),
645
+
]
646
+
);
647
+
}
648
+
649
+
#[tokio::test]
650
+
async fn order_push_only() {
651
+
let location = location!(get_test_path!());
652
+
let mut node = Node::default();
653
+
let name = &Name(function_name!().into());
654
+
let mut context = Context::create_test_context(location, name, &mut node);
655
+
656
+
let Objective::Apply(ref mut apply_objective) = context.objective else {
657
+
unreachable!()
658
+
};
659
+
apply_objective.goal = Goal::Push;
660
+
661
+
let executor = GoalExecutor::new(context);
662
+
let steps = get_steps(executor);
663
+
664
+
assert_eq!(
665
+
steps,
666
+
vec![
667
+
Ping.into(),
668
+
crate::hive::steps::evaluate::Evaluate.into(),
669
+
crate::hive::steps::push::PushEvaluatedOutput.into(),
670
+
]
671
+
);
672
+
}
673
+
674
+
#[tokio::test]
675
+
async fn order_remote_build() {
676
+
let location = location!(get_test_path!());
677
+
let mut node = Node {
678
+
build_remotely: true,
679
+
..Default::default()
680
+
};
681
+
682
+
let name = &Name(function_name!().into());
683
+
let executor = GoalExecutor::new(Context::create_test_context(location, name, &mut node));
684
+
let steps = get_steps(executor);
685
+
686
+
assert_eq!(
687
+
steps,
688
+
vec![
689
+
Ping.into(),
690
+
PushKeyAgent.into(),
691
+
Keys {
692
+
filter: UploadKeyAt::PreActivation
693
+
}
694
+
.into(),
695
+
crate::hive::steps::evaluate::Evaluate.into(),
696
+
crate::hive::steps::push::PushEvaluatedOutput.into(),
697
+
crate::hive::steps::build::Build.into(),
698
+
SwitchToConfiguration.into(),
699
+
Keys {
700
+
filter: UploadKeyAt::PostActivation
701
+
}
702
+
.into(),
703
+
]
704
+
);
705
+
}
706
+
707
+
#[tokio::test]
708
+
async fn order_nokeys() {
709
+
let location = location!(get_test_path!());
710
+
let mut node = Node::default();
711
+
712
+
let name = &Name(function_name!().into());
713
+
let mut context = Context::create_test_context(location, name, &mut node);
714
+
715
+
let Objective::Apply(ref mut apply_objective) = context.objective else {
716
+
unreachable!()
717
+
};
718
+
apply_objective.no_keys = true;
719
+
720
+
let executor = GoalExecutor::new(context);
721
+
let steps = get_steps(executor);
722
+
723
+
assert_eq!(
724
+
steps,
725
+
vec![
726
+
Ping.into(),
727
+
crate::hive::steps::evaluate::Evaluate.into(),
728
+
crate::hive::steps::build::Build.into(),
729
+
crate::hive::steps::push::PushBuildOutput.into(),
730
+
SwitchToConfiguration.into(),
731
+
]
732
+
);
733
+
}
734
+
735
+
#[tokio::test]
736
+
async fn order_should_apply_locally() {
737
+
let location = location!(get_test_path!());
738
+
let mut node = Node::default();
739
+
740
+
let name = &Name(function_name!().into());
741
+
let mut context = Context::create_test_context(location, name, &mut node);
742
+
743
+
let Objective::Apply(ref mut apply_objective) = context.objective else {
744
+
unreachable!()
745
+
};
746
+
apply_objective.no_keys = true;
747
+
apply_objective.should_apply_locally = true;
748
+
749
+
let executor = GoalExecutor::new(context);
750
+
let steps = get_steps(executor);
751
+
752
+
assert_eq!(
753
+
steps,
754
+
vec![
755
+
crate::hive::steps::evaluate::Evaluate.into(),
756
+
crate::hive::steps::build::Build.into(),
757
+
SwitchToConfiguration.into(),
758
+
]
759
+
);
760
+
}
761
+
762
+
#[tokio::test]
763
+
async fn order_build_only() {
764
+
let location = location!(get_test_path!());
765
+
let mut node = Node::default();
766
+
767
+
let name = &Name(function_name!().into());
768
+
let mut context = Context::create_test_context(location, name, &mut node);
769
+
770
+
context.objective = Objective::BuildLocally;
771
+
772
+
let executor = GoalExecutor::new(context);
773
+
let steps = get_steps(executor);
774
+
775
+
assert_eq!(
776
+
steps,
777
+
vec![
778
+
crate::hive::steps::evaluate::Evaluate.into(),
779
+
crate::hive::steps::build::Build.into()
780
+
]
781
+
);
782
+
}
783
+
784
+
#[test]
785
+
fn target_fails_increments() {
786
+
let mut target = Target::from_host("localhost");
787
+
788
+
assert_eq!(target.current_host, 0);
789
+
790
+
for i in 0..100 {
791
+
target.host_failed();
792
+
assert_eq!(target.current_host, i + 1);
793
+
}
794
+
}
795
+
796
+
#[test]
797
+
fn get_preferred_host_fails() {
798
+
let mut target = Target {
799
+
hosts: vec![
800
+
"un.reachable.1".into(),
801
+
"un.reachable.2".into(),
802
+
"un.reachable.3".into(),
803
+
"un.reachable.4".into(),
804
+
"un.reachable.5".into(),
805
+
],
806
+
..Default::default()
807
+
};
808
+
809
+
assert_ne!(
810
+
target.get_preferred_host().unwrap().to_string(),
811
+
"un.reachable.5"
812
+
);
813
+
814
+
for i in 1..=5 {
815
+
assert_eq!(
816
+
target.get_preferred_host().unwrap().to_string(),
817
+
format!("un.reachable.{i}")
818
+
);
819
+
target.host_failed();
820
+
}
821
+
822
+
for _ in 0..5 {
823
+
assert_matches!(
824
+
target.get_preferred_host(),
825
+
Err(HiveLibError::NetworkError(NetworkError::HostsExhausted))
826
+
);
827
+
}
828
+
}
829
+
830
+
#[test]
831
+
fn test_ssh_opts() {
832
+
let target = Target::from_host("hello-world");
833
+
let subcommand_modifiers = SubCommandModifiers {
834
+
non_interactive: false,
835
+
..Default::default()
836
+
};
837
+
let tmp = format!(
838
+
"/tmp/{}",
839
+
rand::distr::SampleString::sample_string(&Alphabetic, &mut rand::rng(), 10)
840
+
);
841
+
842
+
std::fs::create_dir(&tmp).unwrap();
843
+
844
+
unsafe { env::set_var("XDG_RUNTIME_DIR", &tmp) }
845
+
846
+
let args = [
847
+
"-l".to_string(),
848
+
target.user.to_string(),
849
+
"-p".to_string(),
850
+
target.port.to_string(),
851
+
"-o".to_string(),
852
+
"StrictHostKeyChecking=accept-new".to_string(),
853
+
"-o".to_string(),
854
+
"PasswordAuthentication=no".to_string(),
855
+
"-o".to_string(),
856
+
"KbdInteractiveAuthentication=no".to_string(),
857
+
];
858
+
859
+
assert_eq!(
860
+
target
861
+
.create_ssh_args(subcommand_modifiers, false, false)
862
+
.unwrap(),
863
+
args
864
+
);
865
+
assert_eq!(
866
+
target.create_ssh_opts(subcommand_modifiers, false).unwrap(),
867
+
args.join(" ")
868
+
);
869
+
870
+
assert_eq!(
871
+
target
872
+
.create_ssh_args(subcommand_modifiers, false, true)
873
+
.unwrap(),
874
+
[
875
+
"-l".to_string(),
876
+
target.user.to_string(),
877
+
"-p".to_string(),
878
+
target.port.to_string(),
879
+
"-o".to_string(),
880
+
"StrictHostKeyChecking=accept-new".to_string(),
881
+
"-o".to_string(),
882
+
"PasswordAuthentication=no".to_string(),
883
+
"-o".to_string(),
884
+
"KbdInteractiveAuthentication=no".to_string(),
885
+
]
886
+
);
887
+
888
+
assert_eq!(
889
+
target
890
+
.create_ssh_args(subcommand_modifiers, true, true)
891
+
.unwrap(),
892
+
[
893
+
"-l".to_string(),
894
+
target.user.to_string(),
895
+
"-p".to_string(),
896
+
target.port.to_string(),
897
+
"-o".to_string(),
898
+
"StrictHostKeyChecking=accept-new".to_string(),
899
+
"-o".to_string(),
900
+
"PasswordAuthentication=no".to_string(),
901
+
"-o".to_string(),
902
+
"KbdInteractiveAuthentication=no".to_string(),
903
+
]
904
+
);
905
+
906
+
// forced non interactive is the same as --non-interactive
907
+
assert_eq!(
908
+
target
909
+
.create_ssh_args(subcommand_modifiers, true, false)
910
+
.unwrap(),
911
+
target
912
+
.create_ssh_args(
913
+
SubCommandModifiers {
914
+
non_interactive: true,
915
+
..Default::default()
916
+
},
917
+
false,
918
+
false
919
+
)
920
+
.unwrap()
921
+
);
922
+
}
923
+
924
+
#[tokio::test]
925
+
async fn context_quits_sigint() {
926
+
let location = location!(get_test_path!());
927
+
let mut node = Node::default();
928
+
929
+
let name = &Name(function_name!().into());
930
+
let context = Context::create_test_context(location, name, &mut node);
931
+
context
932
+
.should_quit
933
+
.store(true, std::sync::atomic::Ordering::Relaxed);
934
+
let executor = GoalExecutor::new(context);
935
+
let status = executor.execute().await;
936
+
937
+
assert_matches!(status, Err(HiveLibError::Sigint));
938
+
}
939
+
}
+219
crates/core/src/hive/steps/activate.rs
+219
crates/core/src/hive/steps/activate.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use tracing::{error, info, instrument, warn};
7
+
8
+
use crate::{
9
+
HiveLibError,
10
+
commands::{CommandArguments, WireCommandChip, builder::CommandStringBuilder, run_command},
11
+
errors::{ActivationError, NetworkError},
12
+
hive::node::{Context, ExecuteStep, Goal, Objective, SwitchToConfigurationGoal},
13
+
};
14
+
15
+
#[derive(Debug, PartialEq)]
16
+
pub struct SwitchToConfiguration;
17
+
18
+
impl Display for SwitchToConfiguration {
19
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20
+
write!(f, "switch-to-configuration")
21
+
}
22
+
}
23
+
24
+
async fn wait_for_ping(ctx: &Context<'_>) -> Result<(), HiveLibError> {
25
+
let host = ctx.node.target.get_preferred_host()?;
26
+
let mut result = ctx.node.ping(ctx.modifiers).await;
27
+
28
+
for num in 0..2 {
29
+
warn!("Trying to ping {host} (attempt {}/3)", num + 1);
30
+
31
+
result = ctx.node.ping(ctx.modifiers).await;
32
+
33
+
if result.is_ok() {
34
+
info!("Regained connection to {} via {host}", ctx.name);
35
+
36
+
break;
37
+
}
38
+
}
39
+
40
+
result
41
+
}
42
+
43
+
async fn set_profile(
44
+
goal: SwitchToConfigurationGoal,
45
+
built_path: &String,
46
+
ctx: &Context<'_>,
47
+
) -> Result<(), HiveLibError> {
48
+
info!("Setting profiles in anticipation for switch-to-configuration {goal}");
49
+
50
+
let mut command_string = CommandStringBuilder::new("nix-env");
51
+
command_string.args(&["-p", "/nix/var/nix/profiles/system", "--set"]);
52
+
command_string.arg(built_path);
53
+
54
+
let Objective::Apply(apply_objective) = ctx.objective else {
55
+
unreachable!()
56
+
};
57
+
58
+
let child = run_command(
59
+
&CommandArguments::new(command_string, ctx.modifiers)
60
+
.mode(crate::commands::ChildOutputMode::Nix)
61
+
.execute_on_remote(if apply_objective.should_apply_locally {
62
+
None
63
+
} else {
64
+
Some(&ctx.node.target)
65
+
})
66
+
.elevated(ctx.node),
67
+
)
68
+
.await?;
69
+
70
+
let _ = child
71
+
.wait_till_success()
72
+
.await
73
+
.map_err(HiveLibError::CommandError)?;
74
+
75
+
info!("Set system profile");
76
+
77
+
Ok(())
78
+
}
79
+
80
+
impl ExecuteStep for SwitchToConfiguration {
81
+
fn should_execute(&self, ctx: &Context) -> bool {
82
+
let Objective::Apply(apply_objective) = ctx.objective else {
83
+
return false;
84
+
};
85
+
86
+
matches!(apply_objective.goal, Goal::SwitchToConfiguration(..))
87
+
}
88
+
89
+
#[allow(clippy::too_many_lines)]
90
+
#[instrument(skip_all, name = "activate")]
91
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
92
+
let built_path = ctx.state.build.as_ref().unwrap();
93
+
94
+
let Objective::Apply(apply_objective) = ctx.objective else {
95
+
unreachable!()
96
+
};
97
+
98
+
let Goal::SwitchToConfiguration(goal) = &apply_objective.goal else {
99
+
unreachable!("Cannot reach as guarded by should_execute")
100
+
};
101
+
102
+
if matches!(
103
+
goal,
104
+
// switch profile if switch or boot
105
+
// https://github.com/NixOS/nixpkgs/blob/a2c92aa34735a04010671e3378e2aa2d109b2a72/pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/services.py#L224
106
+
SwitchToConfigurationGoal::Switch | SwitchToConfigurationGoal::Boot
107
+
) {
108
+
set_profile(*goal, built_path, ctx).await?;
109
+
}
110
+
111
+
info!("Running switch-to-configuration {goal}");
112
+
113
+
let mut command_string =
114
+
CommandStringBuilder::new(format!("{built_path}/bin/switch-to-configuration"));
115
+
command_string.arg(match goal {
116
+
SwitchToConfigurationGoal::Switch => "switch",
117
+
SwitchToConfigurationGoal::Boot => "boot",
118
+
SwitchToConfigurationGoal::Test => "test",
119
+
SwitchToConfigurationGoal::DryActivate => "dry-activate",
120
+
});
121
+
122
+
let child = run_command(
123
+
&CommandArguments::new(command_string, ctx.modifiers)
124
+
.execute_on_remote(if apply_objective.should_apply_locally {
125
+
None
126
+
} else {
127
+
Some(&ctx.node.target)
128
+
})
129
+
.elevated(ctx.node)
130
+
.log_stdout(),
131
+
)
132
+
.await?;
133
+
134
+
let result = child.wait_till_success().await;
135
+
136
+
match result {
137
+
Ok(_) => {
138
+
if !apply_objective.reboot {
139
+
return Ok(());
140
+
}
141
+
142
+
if apply_objective.should_apply_locally {
143
+
error!("Refusing to reboot local machine!");
144
+
145
+
return Ok(());
146
+
}
147
+
148
+
warn!("Rebooting {name}!", name = ctx.name);
149
+
150
+
let reboot = run_command(
151
+
&CommandArguments::new("reboot now", ctx.modifiers)
152
+
.log_stdout()
153
+
.execute_on_remote(Some(&ctx.node.target))
154
+
.elevated(ctx.node),
155
+
)
156
+
.await?;
157
+
158
+
// consume result, impossible to know if the machine failed to reboot or we
159
+
// simply disconnected
160
+
let _ = reboot
161
+
.wait_till_success()
162
+
.await
163
+
.map_err(HiveLibError::CommandError)?;
164
+
165
+
info!("Rebooted {name}, waiting to reconnect...", name = ctx.name);
166
+
167
+
if wait_for_ping(ctx).await.is_ok() {
168
+
return Ok(());
169
+
}
170
+
171
+
error!(
172
+
"Failed to get regain connection to {name} via {host} after reboot.",
173
+
name = ctx.name,
174
+
host = ctx.node.target.get_preferred_host()?
175
+
);
176
+
177
+
return Err(HiveLibError::NetworkError(
178
+
NetworkError::HostUnreachableAfterReboot(
179
+
ctx.node.target.get_preferred_host()?.to_string(),
180
+
),
181
+
));
182
+
}
183
+
Err(error) => {
184
+
warn!(
185
+
"Activation command for {name} exited unsuccessfully.",
186
+
name = ctx.name
187
+
);
188
+
189
+
// Bail if the command couldn't of broken the system
190
+
// and don't try to regain connection to localhost
191
+
if matches!(goal, SwitchToConfigurationGoal::DryActivate)
192
+
|| apply_objective.should_apply_locally
193
+
{
194
+
return Err(HiveLibError::ActivationError(
195
+
ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
196
+
));
197
+
}
198
+
199
+
if wait_for_ping(ctx).await.is_ok() {
200
+
return Err(HiveLibError::ActivationError(
201
+
ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
202
+
));
203
+
}
204
+
205
+
error!(
206
+
"Failed to get regain connection to {name} via {host} after {goal} activation.",
207
+
name = ctx.name,
208
+
host = ctx.node.target.get_preferred_host()?
209
+
);
210
+
211
+
return Err(HiveLibError::NetworkError(
212
+
NetworkError::HostUnreachableAfterReboot(
213
+
ctx.node.target.get_preferred_host()?.to_string(),
214
+
),
215
+
));
216
+
}
217
+
}
218
+
}
219
+
}
+89
crates/core/src/hive/steps/build.rs
+89
crates/core/src/hive/steps/build.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use tracing::{info, instrument};
7
+
8
+
use crate::{
9
+
HiveLibError,
10
+
commands::{
11
+
CommandArguments, Either, WireCommandChip, builder::CommandStringBuilder,
12
+
run_command_with_env,
13
+
},
14
+
hive::node::{Context, ExecuteStep, Goal, Objective},
15
+
};
16
+
17
+
#[derive(Debug, PartialEq)]
18
+
pub struct Build;
19
+
20
+
impl Display for Build {
21
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
22
+
write!(f, "Build the node")
23
+
}
24
+
}
25
+
26
+
impl ExecuteStep for Build {
27
+
fn should_execute(&self, ctx: &Context) -> bool {
28
+
match ctx.objective {
29
+
Objective::Apply(apply_objective) => {
30
+
!matches!(apply_objective.goal, Goal::Keys | Goal::Push)
31
+
}
32
+
Objective::BuildLocally => true,
33
+
}
34
+
}
35
+
36
+
#[instrument(skip_all, name = "build")]
37
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
38
+
let top_level = ctx.state.evaluation.as_ref().unwrap();
39
+
40
+
let mut command_string = CommandStringBuilder::nix();
41
+
command_string.args(&[
42
+
"--extra-experimental-features",
43
+
"nix-command",
44
+
"build",
45
+
"--print-build-logs",
46
+
"--no-link",
47
+
"--print-out-paths",
48
+
]);
49
+
command_string.arg(top_level.to_string());
50
+
51
+
let status = run_command_with_env(
52
+
&CommandArguments::new(command_string, ctx.modifiers)
53
+
// build remotely if asked for AND we arent applying locally
54
+
.execute_on_remote(
55
+
if ctx.node.build_remotely
56
+
&& let Objective::Apply(apply_objective) = ctx.objective
57
+
&& !apply_objective.should_apply_locally
58
+
{
59
+
Some(&ctx.node.target)
60
+
} else {
61
+
None
62
+
},
63
+
)
64
+
.mode(crate::commands::ChildOutputMode::Nix)
65
+
.log_stdout(),
66
+
std::collections::HashMap::new(),
67
+
)
68
+
.await?
69
+
.wait_till_success()
70
+
.await
71
+
.map_err(|source| HiveLibError::NixBuildError {
72
+
name: ctx.name.clone(),
73
+
source,
74
+
})?;
75
+
76
+
let stdout = match status {
77
+
Either::Left((_, stdout)) | Either::Right((_, stdout)) => stdout,
78
+
};
79
+
80
+
info!("Built output: {stdout:?}");
81
+
82
+
// print built path to stdout
83
+
println!("{stdout}");
84
+
85
+
ctx.state.build = Some(stdout);
86
+
87
+
Ok(())
88
+
}
89
+
}
+28
crates/core/src/hive/steps/cleanup.rs
+28
crates/core/src/hive/steps/cleanup.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use crate::{
7
+
errors::HiveLibError,
8
+
hive::node::{Context, ExecuteStep},
9
+
};
10
+
11
+
#[derive(PartialEq, Debug)]
12
+
pub(crate) struct CleanUp;
13
+
14
+
impl Display for CleanUp {
15
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16
+
write!(f, "Clean up")
17
+
}
18
+
}
19
+
20
+
impl ExecuteStep for CleanUp {
21
+
fn should_execute(&self, _ctx: &Context) -> bool {
22
+
false
23
+
}
24
+
25
+
async fn execute(&self, _ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
26
+
Ok(())
27
+
}
28
+
}
+38
crates/core/src/hive/steps/evaluate.rs
+38
crates/core/src/hive/steps/evaluate.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use tracing::instrument;
7
+
8
+
use crate::{
9
+
HiveLibError,
10
+
hive::node::{Context, ExecuteStep, Goal, Objective},
11
+
};
12
+
13
+
#[derive(Debug, PartialEq)]
14
+
pub struct Evaluate;
15
+
16
+
impl Display for Evaluate {
17
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18
+
write!(f, "Evaluate the node")
19
+
}
20
+
}
21
+
22
+
impl ExecuteStep for Evaluate {
23
+
fn should_execute(&self, ctx: &Context) -> bool {
24
+
match ctx.objective {
25
+
Objective::Apply(apply_objective) => !matches!(apply_objective.goal, Goal::Keys),
26
+
Objective::BuildLocally => true,
27
+
}
28
+
}
29
+
30
+
#[instrument(skip_all, name = "eval")]
31
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
32
+
let rx = ctx.state.evaluation_rx.take().unwrap();
33
+
34
+
ctx.state.evaluation = Some(rx.await.unwrap()?);
35
+
36
+
Ok(())
37
+
}
38
+
}
+441
crates/core/src/hive/steps/keys.rs
+441
crates/core/src/hive/steps/keys.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use base64::Engine;
5
+
use base64::prelude::BASE64_STANDARD;
6
+
use futures::future::join_all;
7
+
use im::Vector;
8
+
use itertools::{Itertools, Position};
9
+
use owo_colors::OwoColorize;
10
+
use prost::Message;
11
+
use prost::bytes::BytesMut;
12
+
use serde::{Deserialize, Serialize};
13
+
use sha2::{Digest, Sha256};
14
+
use std::env;
15
+
use std::fmt::Display;
16
+
use std::io::Cursor;
17
+
use std::iter::Peekable;
18
+
use std::path::PathBuf;
19
+
use std::pin::Pin;
20
+
use std::process::Stdio;
21
+
use std::str::from_utf8;
22
+
use std::vec::IntoIter;
23
+
use tokio::io::AsyncReadExt as _;
24
+
use tokio::process::Command;
25
+
use tokio::{fs::File, io::AsyncRead};
26
+
use tokio_util::codec::LengthDelimitedCodec;
27
+
use tracing::{debug, instrument};
28
+
29
+
use crate::HiveLibError;
30
+
use crate::commands::builder::CommandStringBuilder;
31
+
use crate::commands::common::push;
32
+
use crate::commands::{CommandArguments, WireCommandChip, run_command};
33
+
use crate::errors::KeyError;
34
+
use crate::hive::node::{Context, ExecuteStep, Goal, Objective, Push, SwitchToConfigurationGoal};
35
+
36
+
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
37
+
#[serde(tag = "t", content = "c")]
38
+
pub enum Source {
39
+
String(String),
40
+
Path(PathBuf),
41
+
Command(Vec<String>),
42
+
}
43
+
44
+
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
45
+
pub enum UploadKeyAt {
46
+
#[serde(rename = "pre-activation")]
47
+
PreActivation,
48
+
#[serde(rename = "post-activation")]
49
+
PostActivation,
50
+
#[serde(skip)]
51
+
NoFilter,
52
+
}
53
+
54
+
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
55
+
pub struct Key {
56
+
pub name: String,
57
+
#[serde(rename = "destDir")]
58
+
pub dest_dir: String,
59
+
pub path: PathBuf,
60
+
pub group: String,
61
+
pub user: String,
62
+
pub permissions: String,
63
+
pub source: Source,
64
+
#[serde(rename = "uploadAt")]
65
+
pub upload_at: UploadKeyAt,
66
+
#[serde(default)]
67
+
pub environment: im::HashMap<String, String>,
68
+
}
69
+
70
+
impl Display for Key {
71
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
72
+
write!(
73
+
f,
74
+
"{} {} {}:{} {}",
75
+
match self.source {
76
+
Source::String(_) => "Literal",
77
+
Source::Path(_) => "Path",
78
+
Source::Command(_) => "Command",
79
+
}
80
+
.if_supports_color(owo_colors::Stream::Stdout, |x| x.dimmed()),
81
+
[self.dest_dir.clone(), self.name.clone()]
82
+
.iter()
83
+
.collect::<PathBuf>()
84
+
.display(),
85
+
self.user,
86
+
self.group,
87
+
self.permissions,
88
+
)
89
+
}
90
+
}
91
+
92
+
#[cfg(test)]
93
+
impl Default for Key {
94
+
fn default() -> Self {
95
+
use im::HashMap;
96
+
97
+
Self {
98
+
name: "key".into(),
99
+
dest_dir: "/somewhere/".into(),
100
+
path: "key".into(),
101
+
group: "root".into(),
102
+
user: "root".into(),
103
+
permissions: "0600".into(),
104
+
source: Source::String("test key".into()),
105
+
upload_at: UploadKeyAt::PreActivation,
106
+
environment: HashMap::new(),
107
+
}
108
+
}
109
+
}
110
+
111
+
fn get_u32_unix_mode(key: &Key) -> Result<u32, KeyError> {
112
+
u32::from_str_radix(&key.permissions, 8).map_err(KeyError::ParseKeyPermissions)
113
+
}
114
+
115
+
async fn create_reader(key: &'_ Key) -> Result<Pin<Box<dyn AsyncRead + Send + '_>>, KeyError> {
116
+
match &key.source {
117
+
Source::Path(path) => Ok(Box::pin(File::open(path).await.map_err(KeyError::File)?)),
118
+
Source::String(string) => Ok(Box::pin(Cursor::new(string))),
119
+
Source::Command(args) => {
120
+
let output = Command::new(args.first().ok_or(KeyError::Empty)?)
121
+
.args(&args[1..])
122
+
.stdin(Stdio::null())
123
+
.stdout(Stdio::piped())
124
+
.stderr(Stdio::piped())
125
+
.envs(key.environment.clone())
126
+
.spawn()
127
+
.map_err(|err| KeyError::CommandSpawnError {
128
+
error: err,
129
+
command: args.join(" "),
130
+
command_span: Some((0..args.first().unwrap().len()).into()),
131
+
})?
132
+
.wait_with_output()
133
+
.await
134
+
.map_err(|err| KeyError::CommandResolveError {
135
+
error: err,
136
+
command: args.join(" "),
137
+
})?;
138
+
139
+
if output.status.success() {
140
+
return Ok(Box::pin(Cursor::new(output.stdout)));
141
+
}
142
+
143
+
Err(KeyError::CommandError(
144
+
output.status,
145
+
from_utf8(&output.stderr).unwrap().to_string(),
146
+
))
147
+
}
148
+
}
149
+
}
150
+
151
+
async fn process_key(key: &Key) -> Result<(wire_key_agent::keys::KeySpec, Vec<u8>), KeyError> {
152
+
let mut reader = create_reader(key).await?;
153
+
154
+
let mut buf = Vec::new();
155
+
156
+
reader
157
+
.read_to_end(&mut buf)
158
+
.await
159
+
.expect("failed to read into buffer");
160
+
161
+
let destination: PathBuf = [key.dest_dir.clone(), key.name.clone()].iter().collect();
162
+
163
+
debug!("Staging push to {}", destination.clone().display());
164
+
165
+
Ok((
166
+
wire_key_agent::keys::KeySpec {
167
+
length: buf
168
+
.len()
169
+
.try_into()
170
+
.expect("Failed to convert usize buf length to i32"),
171
+
user: key.user.clone(),
172
+
group: key.group.clone(),
173
+
unix_mode: get_u32_unix_mode(key)?,
174
+
destination: destination.into_os_string().into_string().unwrap(),
175
+
digest: Sha256::digest(&buf).to_vec(),
176
+
last: false,
177
+
},
178
+
buf,
179
+
))
180
+
}
181
+
182
+
#[derive(Debug, PartialEq)]
183
+
pub struct Keys {
184
+
pub filter: UploadKeyAt,
185
+
}
186
+
#[derive(Debug, PartialEq)]
187
+
pub struct PushKeyAgent;
188
+
189
+
impl Display for Keys {
190
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
191
+
write!(f, "Upload key @ {:?}", self.filter)
192
+
}
193
+
}
194
+
195
+
impl Display for PushKeyAgent {
196
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197
+
write!(f, "Push the key agent")
198
+
}
199
+
}
200
+
201
+
pub struct SimpleLengthDelimWriter<F> {
202
+
codec: LengthDelimitedCodec,
203
+
write_fn: F,
204
+
}
205
+
206
+
impl<F> SimpleLengthDelimWriter<F>
207
+
where
208
+
F: AsyncFnMut(Vec<u8>) -> Result<(), HiveLibError>,
209
+
{
210
+
fn new(write_fn: F) -> Self {
211
+
Self {
212
+
codec: LengthDelimitedCodec::new(),
213
+
write_fn,
214
+
}
215
+
}
216
+
217
+
async fn send(&mut self, data: prost::bytes::Bytes) -> Result<(), HiveLibError> {
218
+
let mut buffer = BytesMut::new();
219
+
tokio_util::codec::Encoder::encode(&mut self.codec, data, &mut buffer)
220
+
.map_err(HiveLibError::Encoding)?;
221
+
222
+
(self.write_fn)(buffer.to_vec()).await?;
223
+
Ok(())
224
+
}
225
+
}
226
+
227
+
impl ExecuteStep for Keys {
228
+
fn should_execute(&self, ctx: &Context) -> bool {
229
+
let Objective::Apply(apply_objective) = ctx.objective else {
230
+
return false;
231
+
};
232
+
233
+
if apply_objective.no_keys {
234
+
return false;
235
+
}
236
+
237
+
// should execute if no filter, and the goal is keys.
238
+
// otherwise, only execute if the goal is switch and non-nofilter
239
+
matches!(
240
+
(&self.filter, &apply_objective.goal),
241
+
(UploadKeyAt::NoFilter, Goal::Keys)
242
+
| (
243
+
UploadKeyAt::PreActivation | UploadKeyAt::PostActivation,
244
+
Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch)
245
+
)
246
+
)
247
+
}
248
+
249
+
#[instrument(skip_all, name = "keys")]
250
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
251
+
let agent_directory = ctx.state.key_agent_directory.as_ref().unwrap();
252
+
253
+
let mut keys = self.select_keys(&ctx.node.keys).await?;
254
+
255
+
if keys.peek().is_none() {
256
+
debug!("Had no keys to push, ending KeyStep early.");
257
+
return Ok(());
258
+
}
259
+
260
+
let command_string =
261
+
CommandStringBuilder::new(format!("{agent_directory}/bin/wire-key-agent"));
262
+
263
+
let Objective::Apply(apply_objective) = ctx.objective else {
264
+
unreachable!()
265
+
};
266
+
267
+
let mut child = run_command(
268
+
&CommandArguments::new(command_string, ctx.modifiers)
269
+
.execute_on_remote(if apply_objective.should_apply_locally {
270
+
None
271
+
} else {
272
+
Some(&ctx.node.target)
273
+
})
274
+
.elevated(ctx.node)
275
+
.keep_stdin_open()
276
+
.log_stdout(),
277
+
)
278
+
.await?;
279
+
280
+
let mut writer = SimpleLengthDelimWriter::new(async |data| child.write_stdin(data).await);
281
+
282
+
for (position, (mut spec, buf)) in keys.with_position() {
283
+
if matches!(position, Position::Last | Position::Only) {
284
+
spec.last = true;
285
+
}
286
+
287
+
debug!("Writing spec & buf for {:?}", spec);
288
+
289
+
writer
290
+
.send(BASE64_STANDARD.encode(spec.encode_to_vec()).into())
291
+
.await?;
292
+
writer.send(BASE64_STANDARD.encode(buf).into()).await?;
293
+
}
294
+
295
+
let status = child
296
+
.wait_till_success()
297
+
.await
298
+
.map_err(HiveLibError::CommandError)?;
299
+
300
+
debug!("status: {status:?}");
301
+
302
+
Ok(())
303
+
}
304
+
}
305
+
306
+
impl Keys {
307
+
async fn select_keys(
308
+
&self,
309
+
keys: &Vector<Key>,
310
+
) -> Result<Peekable<IntoIter<(wire_key_agent::keys::KeySpec, std::vec::Vec<u8>)>>, HiveLibError>
311
+
{
312
+
let futures = keys
313
+
.iter()
314
+
.filter(|key| self.filter == UploadKeyAt::NoFilter || (key.upload_at == self.filter))
315
+
.map(|key| async move {
316
+
process_key(key)
317
+
.await
318
+
.map_err(|err| HiveLibError::KeyError(key.name.clone(), err))
319
+
});
320
+
321
+
Ok(join_all(futures)
322
+
.await
323
+
.into_iter()
324
+
.collect::<Result<Vec<_>, HiveLibError>>()?
325
+
.into_iter()
326
+
.peekable())
327
+
}
328
+
}
329
+
330
+
impl ExecuteStep for PushKeyAgent {
331
+
fn should_execute(&self, ctx: &Context) -> bool {
332
+
let Objective::Apply(apply_objective) = ctx.objective else {
333
+
return false;
334
+
};
335
+
336
+
if apply_objective.no_keys {
337
+
return false;
338
+
}
339
+
340
+
matches!(
341
+
&apply_objective.goal,
342
+
Goal::Keys | Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch)
343
+
)
344
+
}
345
+
346
+
#[instrument(skip_all, name = "push_agent")]
347
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
348
+
let arg_name = format!(
349
+
"WIRE_KEY_AGENT_{platform}",
350
+
platform = ctx.node.host_platform.replace('-', "_")
351
+
);
352
+
353
+
let agent_directory = match env::var_os(&arg_name) {
354
+
Some(agent) => agent.into_string().unwrap(),
355
+
None => panic!(
356
+
"{arg_name} environment variable not set! \n
357
+
wire was not built with the ability to deploy keys to this platform. \n
358
+
Please create an issue: https://github.com/forallsys/wire/issues/new?template=bug_report.md"
359
+
),
360
+
};
361
+
362
+
let Objective::Apply(apply_objective) = ctx.objective else {
363
+
unreachable!()
364
+
};
365
+
366
+
if !apply_objective.should_apply_locally {
367
+
push(ctx, Push::Path(&agent_directory)).await?;
368
+
}
369
+
370
+
ctx.state.key_agent_directory = Some(agent_directory);
371
+
372
+
Ok(())
373
+
}
374
+
}
375
+
376
+
#[cfg(test)]
377
+
mod tests {
378
+
use im::Vector;
379
+
380
+
use crate::hive::steps::keys::{Key, Keys, UploadKeyAt, process_key};
381
+
382
+
fn new_key(upload_at: &UploadKeyAt) -> Key {
383
+
Key {
384
+
upload_at: upload_at.clone(),
385
+
source: super::Source::String(match upload_at {
386
+
UploadKeyAt::PreActivation => "pre".into(),
387
+
UploadKeyAt::PostActivation => "post".into(),
388
+
UploadKeyAt::NoFilter => "none".into(),
389
+
}),
390
+
..Default::default()
391
+
}
392
+
}
393
+
394
+
#[tokio::test]
395
+
async fn key_filtering() {
396
+
let keys = Vector::from(vec![
397
+
new_key(&UploadKeyAt::PreActivation),
398
+
new_key(&UploadKeyAt::PostActivation),
399
+
new_key(&UploadKeyAt::PreActivation),
400
+
new_key(&UploadKeyAt::PostActivation),
401
+
]);
402
+
403
+
for (_, buf) in (Keys {
404
+
filter: crate::hive::steps::keys::UploadKeyAt::PreActivation,
405
+
})
406
+
.select_keys(&keys)
407
+
.await
408
+
.unwrap()
409
+
{
410
+
assert_eq!(String::from_utf8_lossy(&buf), "pre");
411
+
}
412
+
413
+
for (_, buf) in (Keys {
414
+
filter: crate::hive::steps::keys::UploadKeyAt::PostActivation,
415
+
})
416
+
.select_keys(&keys)
417
+
.await
418
+
.unwrap()
419
+
{
420
+
assert_eq!(String::from_utf8_lossy(&buf), "post");
421
+
}
422
+
423
+
// test that NoFilter processes all keys.
424
+
let processed_all =
425
+
futures::future::join_all(keys.iter().map(async |x| process_key(x).await))
426
+
.await
427
+
.iter()
428
+
.flatten()
429
+
.cloned()
430
+
.collect::<Vec<_>>();
431
+
let no_filter = (Keys {
432
+
filter: crate::hive::steps::keys::UploadKeyAt::NoFilter,
433
+
})
434
+
.select_keys(&keys)
435
+
.await
436
+
.unwrap()
437
+
.collect::<Vec<_>>();
438
+
439
+
assert_eq!(processed_all, no_filter);
440
+
}
441
+
}
+10
crates/core/src/hive/steps/mod.rs
+10
crates/core/src/hive/steps/mod.rs
+58
crates/core/src/hive/steps/ping.rs
+58
crates/core/src/hive/steps/ping.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use tracing::{Level, event, instrument};
7
+
8
+
use crate::{
9
+
HiveLibError,
10
+
hive::node::{Context, ExecuteStep, Objective},
11
+
};
12
+
13
+
#[derive(Debug, PartialEq)]
14
+
pub struct Ping;
15
+
16
+
impl Display for Ping {
17
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18
+
write!(f, "Ping node")
19
+
}
20
+
}
21
+
22
+
impl ExecuteStep for Ping {
23
+
fn should_execute(&self, ctx: &Context) -> bool {
24
+
let Objective::Apply(apply_objective) = ctx.objective else {
25
+
return false;
26
+
};
27
+
28
+
!apply_objective.should_apply_locally
29
+
}
30
+
31
+
#[instrument(skip_all, name = "ping")]
32
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
33
+
loop {
34
+
event!(
35
+
Level::INFO,
36
+
status = "attempting",
37
+
host = ctx.node.target.get_preferred_host()?.to_string()
38
+
);
39
+
40
+
if ctx.node.ping(ctx.modifiers).await.is_ok() {
41
+
event!(
42
+
Level::INFO,
43
+
status = "success",
44
+
host = ctx.node.target.get_preferred_host()?.to_string()
45
+
);
46
+
return Ok(());
47
+
}
48
+
49
+
// ? will take us out if we ran out of hosts
50
+
event!(
51
+
Level::WARN,
52
+
status = "failed to ping",
53
+
host = ctx.node.target.get_preferred_host()?.to_string()
54
+
);
55
+
ctx.node.target.host_failed();
56
+
}
57
+
}
58
+
}
+84
crates/core/src/hive/steps/push.rs
+84
crates/core/src/hive/steps/push.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::fmt::Display;
5
+
6
+
use tracing::instrument;
7
+
8
+
use crate::{
9
+
HiveLibError,
10
+
commands::common::push,
11
+
hive::node::{Context, ExecuteStep, Goal, Objective},
12
+
};
13
+
14
+
#[derive(Debug, PartialEq)]
15
+
pub struct PushEvaluatedOutput;
16
+
#[derive(Debug, PartialEq)]
17
+
pub struct PushBuildOutput;
18
+
19
+
impl Display for PushEvaluatedOutput {
20
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21
+
write!(f, "Push the evaluated output")
22
+
}
23
+
}
24
+
25
+
impl Display for PushBuildOutput {
26
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27
+
write!(f, "Push the build output")
28
+
}
29
+
}
30
+
31
+
impl ExecuteStep for PushEvaluatedOutput {
32
+
fn should_execute(&self, ctx: &Context) -> bool {
33
+
let Objective::Apply(apply_objective) = ctx.objective else {
34
+
return false;
35
+
};
36
+
37
+
!matches!(apply_objective.goal, Goal::Keys)
38
+
&& !apply_objective.should_apply_locally
39
+
&& (ctx.node.build_remotely | matches!(apply_objective.goal, Goal::Push))
40
+
}
41
+
42
+
#[instrument(skip_all, name = "push_eval")]
43
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
44
+
let top_level = ctx.state.evaluation.as_ref().unwrap();
45
+
46
+
push(ctx, crate::hive::node::Push::Derivation(top_level)).await?;
47
+
48
+
Ok(())
49
+
}
50
+
}
51
+
52
+
impl ExecuteStep for PushBuildOutput {
53
+
fn should_execute(&self, ctx: &Context) -> bool {
54
+
let Objective::Apply(apply_objective) = ctx.objective else {
55
+
return false;
56
+
};
57
+
58
+
if matches!(apply_objective.goal, Goal::Keys | Goal::Push) {
59
+
// skip if we are not building
60
+
return false;
61
+
}
62
+
63
+
if ctx.node.build_remotely {
64
+
// skip if we are building remotely
65
+
return false;
66
+
}
67
+
68
+
if apply_objective.should_apply_locally {
69
+
// skip step if we are applying locally
70
+
return false;
71
+
}
72
+
73
+
true
74
+
}
75
+
76
+
#[instrument(skip_all, name = "push_build")]
77
+
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
78
+
let built_path = ctx.state.build.as_ref().unwrap();
79
+
80
+
push(ctx, crate::hive::node::Push::Path(built_path)).await?;
81
+
82
+
Ok(())
83
+
}
84
+
}
+71
crates/core/src/lib.rs
+71
crates/core/src/lib.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#![feature(assert_matches)]
5
+
#![feature(iter_intersperse)]
6
+
#![feature(sync_nonpoison)]
7
+
#![feature(nonpoison_mutex)]
8
+
9
+
use std::{
10
+
io::{IsTerminal, stderr},
11
+
sync::LazyLock,
12
+
};
13
+
14
+
use tokio::sync::{AcquireError, Semaphore, SemaphorePermit};
15
+
16
+
use crate::{errors::HiveLibError, hive::node::Name, status::STATUS};
17
+
18
+
pub mod cache;
19
+
pub mod commands;
20
+
pub mod hive;
21
+
pub mod status;
22
+
23
+
#[cfg(test)]
24
+
mod test_macros;
25
+
26
+
#[cfg(test)]
27
+
mod test_support;
28
+
29
+
pub mod errors;
30
+
31
+
#[derive(Clone, Debug, Copy, Default)]
32
+
pub enum StrictHostKeyChecking {
33
+
/// do not accept new host. dangerous!
34
+
No,
35
+
36
+
/// accept-new, default
37
+
#[default]
38
+
AcceptNew,
39
+
}
40
+
41
+
#[derive(Debug, Clone, Copy)]
42
+
pub struct SubCommandModifiers {
43
+
pub show_trace: bool,
44
+
pub non_interactive: bool,
45
+
pub ssh_accept_host: StrictHostKeyChecking,
46
+
}
47
+
48
+
impl Default for SubCommandModifiers {
49
+
fn default() -> Self {
50
+
SubCommandModifiers {
51
+
show_trace: false,
52
+
non_interactive: !std::io::stdin().is_terminal(),
53
+
ssh_accept_host: StrictHostKeyChecking::default(),
54
+
}
55
+
}
56
+
}
57
+
58
+
pub enum EvalGoal<'a> {
59
+
Inspect,
60
+
Names,
61
+
GetTopLevel(&'a Name),
62
+
}
63
+
64
+
pub static STDIN_CLOBBER_LOCK: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(1));
65
+
66
+
pub async fn acquire_stdin_lock<'a>() -> Result<SemaphorePermit<'a>, AcquireError> {
67
+
let result = STDIN_CLOBBER_LOCK.acquire().await?;
68
+
STATUS.lock().wipe_out(&mut stderr());
69
+
70
+
Ok(result)
71
+
}
+173
crates/core/src/status.rs
+173
crates/core/src/status.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use owo_colors::OwoColorize;
5
+
use std::{fmt::Write, time::Instant};
6
+
use termion::{clear, cursor};
7
+
8
+
use crate::{STDIN_CLOBBER_LOCK, hive::node::Name};
9
+
10
+
use std::{
11
+
collections::HashMap,
12
+
sync::{LazyLock, nonpoison::Mutex},
13
+
};
14
+
15
+
#[derive(Default)]
16
+
pub enum NodeStatus {
17
+
#[default]
18
+
Pending,
19
+
Running(String),
20
+
Succeeded,
21
+
Failed,
22
+
}
23
+
24
+
pub struct Status {
25
+
statuses: HashMap<String, NodeStatus>,
26
+
began: Instant,
27
+
show_progress: bool,
28
+
}
29
+
30
+
/// global status used for the progress bar in the cli crate
31
+
pub static STATUS: LazyLock<Mutex<Status>> = LazyLock::new(|| Mutex::new(Status::new()));
32
+
33
+
impl Status {
34
+
fn new() -> Self {
35
+
Self {
36
+
statuses: HashMap::default(),
37
+
began: Instant::now(),
38
+
show_progress: false,
39
+
}
40
+
}
41
+
42
+
pub const fn show_progress(&mut self, show_progress: bool) {
43
+
self.show_progress = show_progress;
44
+
}
45
+
46
+
pub fn add_many(&mut self, names: &[&Name]) {
47
+
self.statuses.extend(
48
+
names
49
+
.iter()
50
+
.map(|name| (name.0.to_string(), NodeStatus::Pending)),
51
+
);
52
+
}
53
+
54
+
pub fn set_node_step(&mut self, node: &Name, step: String) {
55
+
self.statuses
56
+
.insert(node.0.to_string(), NodeStatus::Running(step));
57
+
}
58
+
59
+
pub fn mark_node_failed(&mut self, node: &Name) {
60
+
self.statuses.insert(node.0.to_string(), NodeStatus::Failed);
61
+
}
62
+
63
+
pub fn mark_node_succeeded(&mut self, node: &Name) {
64
+
self.statuses
65
+
.insert(node.0.to_string(), NodeStatus::Succeeded);
66
+
}
67
+
68
+
#[must_use]
69
+
fn num_finished(&self) -> usize {
70
+
self.statuses
71
+
.iter()
72
+
.filter(|(_, status)| matches!(status, NodeStatus::Succeeded | NodeStatus::Failed))
73
+
.count()
74
+
}
75
+
76
+
#[must_use]
77
+
fn num_running(&self) -> usize {
78
+
self.statuses
79
+
.iter()
80
+
.filter(|(_, status)| matches!(status, NodeStatus::Running(..)))
81
+
.count()
82
+
}
83
+
84
+
#[must_use]
85
+
fn num_failed(&self) -> usize {
86
+
self.statuses
87
+
.iter()
88
+
.filter(|(_, status)| matches!(status, NodeStatus::Failed))
89
+
.count()
90
+
}
91
+
92
+
#[must_use]
93
+
pub fn get_msg(&self) -> String {
94
+
if self.statuses.is_empty() {
95
+
return String::new();
96
+
}
97
+
98
+
let mut msg = format!("[{} / {}", self.num_finished(), self.statuses.len(),);
99
+
100
+
let num_failed = self.num_failed();
101
+
let num_running = self.num_running();
102
+
103
+
let failed = if num_failed >= 1 {
104
+
Some(format!("{} Failed", num_failed.red()))
105
+
} else {
106
+
None
107
+
};
108
+
109
+
let running = if num_running >= 1 {
110
+
Some(format!("{} Deploying", num_running.blue()))
111
+
} else {
112
+
None
113
+
};
114
+
115
+
let _ = match (failed, running) {
116
+
(None, None) => write!(&mut msg, ""),
117
+
(Some(message), None) | (None, Some(message)) => write!(&mut msg, " ({message})"),
118
+
(Some(failed), Some(running)) => write!(&mut msg, " ({failed}, {running})"),
119
+
};
120
+
121
+
let _ = write!(&mut msg, "]");
122
+
123
+
let _ = write!(&mut msg, " {}s", self.began.elapsed().as_secs());
124
+
125
+
msg
126
+
}
127
+
128
+
pub fn clear<T: std::io::Write>(&self, writer: &mut T) {
129
+
if !self.show_progress {
130
+
return;
131
+
}
132
+
133
+
let _ = write!(writer, "{}", cursor::Save);
134
+
// let _ = write!(writer, "{}", cursor::Down(1));
135
+
let _ = write!(writer, "{}", cursor::Left(999));
136
+
let _ = write!(writer, "{}", clear::CurrentLine);
137
+
}
138
+
139
+
/// used when there is an interactive prompt
140
+
pub fn wipe_out<T: std::io::Write>(&self, writer: &mut T) {
141
+
if !self.show_progress {
142
+
return;
143
+
}
144
+
145
+
let _ = write!(writer, "{}", cursor::Save);
146
+
let _ = write!(writer, "{}", cursor::Left(999));
147
+
let _ = write!(writer, "{}", clear::CurrentLine);
148
+
let _ = writer.flush();
149
+
}
150
+
151
+
pub fn write_status<T: std::io::Write>(&mut self, writer: &mut T) {
152
+
if self.show_progress {
153
+
let _ = write!(writer, "{}", self.get_msg());
154
+
}
155
+
}
156
+
157
+
pub fn write_above_status<T: std::io::Write>(
158
+
&mut self,
159
+
buf: &[u8],
160
+
writer: &mut T,
161
+
) -> std::io::Result<usize> {
162
+
if STDIN_CLOBBER_LOCK.available_permits() != 1 {
163
+
// skip
164
+
return Ok(0);
165
+
}
166
+
167
+
self.clear(writer);
168
+
let written = writer.write(buf)?;
169
+
self.write_status(writer);
170
+
171
+
Ok(written)
172
+
}
173
+
}
+43
crates/core/src/test_macros.rs
+43
crates/core/src/test_macros.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#[macro_export]
5
+
macro_rules! function_name {
6
+
() => {{
7
+
fn f() {}
8
+
fn type_name_of<T>(_: T) -> &'static str {
9
+
std::any::type_name::<T>()
10
+
}
11
+
let name = type_name_of(f);
12
+
// closure for async functions
13
+
&name[..name.len() - 3]
14
+
}};
15
+
}
16
+
17
+
#[macro_export]
18
+
macro_rules! get_test_path {
19
+
() => {{
20
+
let mut path: PathBuf = env::var("WIRE_TEST_DIR").unwrap().into();
21
+
let full_name = $crate::function_name!();
22
+
let function_name = full_name
23
+
.trim_end_matches("::{{closure}}")
24
+
.split("::")
25
+
.last()
26
+
.unwrap();
27
+
path.push(function_name);
28
+
29
+
path
30
+
}};
31
+
}
32
+
33
+
#[macro_export]
34
+
macro_rules! location {
35
+
($path:expr) => {{
36
+
$crate::hive::get_hive_location(
37
+
$path.display().to_string(),
38
+
$crate::SubCommandModifiers::default(),
39
+
)
40
+
.await
41
+
.unwrap()
42
+
}};
43
+
}
+67
crates/core/src/test_support.rs
+67
crates/core/src/test_support.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
use std::{
5
+
fs::{self, create_dir},
6
+
io,
7
+
path::Path,
8
+
process::Command,
9
+
};
10
+
11
+
use tempdir::TempDir;
12
+
13
+
pub fn make_flake_sandbox(path: &Path) -> Result<TempDir, io::Error> {
14
+
let tmp_dir = TempDir::new("wire-test")?;
15
+
16
+
Command::new("git")
17
+
.args(["init", "-b", "tmp"])
18
+
.current_dir(tmp_dir.path())
19
+
.status()?;
20
+
21
+
for entry in fs::read_dir(path)? {
22
+
let entry = entry?;
23
+
24
+
fs::copy(entry.path(), tmp_dir.as_ref().join(entry.file_name()))?;
25
+
}
26
+
27
+
let root = path.parent().unwrap().parent().unwrap().parent().unwrap();
28
+
29
+
create_dir(tmp_dir.as_ref().join("module/"))?;
30
+
31
+
fs::copy(
32
+
root.join(Path::new("runtime/evaluate.nix")),
33
+
tmp_dir.as_ref().join("evaluate.nix"),
34
+
)?;
35
+
fs::copy(
36
+
root.join(Path::new("runtime/module/config.nix")),
37
+
tmp_dir.as_ref().join("module/config.nix"),
38
+
)?;
39
+
fs::copy(
40
+
root.join(Path::new("runtime/module/options.nix")),
41
+
tmp_dir.as_ref().join("module/options.nix"),
42
+
)?;
43
+
fs::copy(
44
+
root.join(Path::new("runtime/module/default.nix")),
45
+
tmp_dir.as_ref().join("module/default.nix"),
46
+
)?;
47
+
fs::copy(
48
+
root.join(Path::new("runtime/makeHive.nix")),
49
+
tmp_dir.as_ref().join("makeHive.nix"),
50
+
)?;
51
+
fs::copy(
52
+
root.join(Path::new("flake.lock")),
53
+
tmp_dir.as_ref().join("flake.lock"),
54
+
)?;
55
+
56
+
Command::new("git")
57
+
.args(["add", "-A"])
58
+
.current_dir(tmp_dir.path())
59
+
.status()?;
60
+
61
+
Command::new("nix")
62
+
.args(["flake", "lock"])
63
+
.current_dir(tmp_dir.path())
64
+
.status()?;
65
+
66
+
Ok(tmp_dir)
67
+
}
+20
crates/key_agent/Cargo.toml
+20
crates/key_agent/Cargo.toml
···
1
+
[package]
2
+
name = "wire-key-agent"
3
+
edition.workspace = true
4
+
version.workspace = true
5
+
6
+
[dependencies]
7
+
tokio = { workspace = true }
8
+
tokio-util = { workspace = true }
9
+
anyhow = { workspace = true }
10
+
prost = { workspace = true }
11
+
nix = { workspace = true }
12
+
futures-util = { workspace = true }
13
+
sha2 = { workspace = true }
14
+
base64 = { workspace = true }
15
+
16
+
[build-dependencies]
17
+
prost-build = "0.14"
18
+
19
+
[lints]
20
+
workspace = true
+8
crates/key_agent/build.rs
+8
crates/key_agent/build.rs
+17
crates/key_agent/default.nix
+17
crates/key_agent/default.nix
+17
crates/key_agent/src/keys.proto
+17
crates/key_agent/src/keys.proto
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
syntax = "proto3";
5
+
6
+
package key_agent.keys;
7
+
8
+
message KeySpec {
9
+
string destination = 1;
10
+
string user = 2;
11
+
string group = 3;
12
+
uint32 unix_mode = 4;
13
+
uint32 length = 5;
14
+
bool last = 6;
15
+
/// Sha256 digest
16
+
bytes digest = 7;
17
+
}
+6
crates/key_agent/src/lib.rs
+6
crates/key_agent/src/lib.rs
+94
crates/key_agent/src/main.rs
+94
crates/key_agent/src/main.rs
···
1
+
// SPDX-License-Identifier: AGPL-3.0-or-later
2
+
// Copyright 2024-2025 wire Contributors
3
+
4
+
#![deny(clippy::pedantic)]
5
+
use base64::Engine;
6
+
use base64::prelude::BASE64_STANDARD;
7
+
use futures_util::stream::StreamExt;
8
+
use nix::unistd::{Group, User};
9
+
use prost::Message;
10
+
use prost::bytes::Bytes;
11
+
use sha2::{Digest, Sha256};
12
+
use std::os::unix::fs::PermissionsExt;
13
+
use std::os::unix::fs::chown;
14
+
use std::path::{Path, PathBuf};
15
+
use tokio::fs::File;
16
+
use tokio::io::AsyncWriteExt;
17
+
use tokio_util::codec::{FramedRead, LengthDelimitedCodec};
18
+
use wire_key_agent::keys::KeySpec;
19
+
20
+
fn create_path(key_path: &Path) -> Result<(), anyhow::Error> {
21
+
let prefix = key_path.parent().unwrap();
22
+
std::fs::create_dir_all(prefix)?;
23
+
24
+
Ok(())
25
+
}
26
+
27
+
fn pretty_keyspec(spec: &KeySpec) -> String {
28
+
format!(
29
+
"{} {}:{} {:o}",
30
+
spec.destination, spec.user, spec.group, spec.unix_mode
31
+
)
32
+
}
33
+
34
+
#[tokio::main]
35
+
async fn main() -> Result<(), anyhow::Error> {
36
+
let stdin = tokio::io::stdin();
37
+
38
+
let mut framed = FramedRead::new(stdin, LengthDelimitedCodec::new());
39
+
40
+
while let Some(spec_bytes) = framed.next().await {
41
+
let spec_bytes = Bytes::from(BASE64_STANDARD.decode(spec_bytes?)?);
42
+
let spec = KeySpec::decode(spec_bytes)?;
43
+
44
+
let key_bytes = BASE64_STANDARD.decode(
45
+
framed
46
+
.next()
47
+
.await
48
+
.expect("expected key_bytes to come after spec_bytes")?,
49
+
)?;
50
+
51
+
let digest = Sha256::digest(&key_bytes).to_vec();
52
+
53
+
println!(
54
+
"Writing {}, {:?} bytes of data",
55
+
pretty_keyspec(&spec),
56
+
key_bytes.len()
57
+
);
58
+
59
+
if digest != spec.digest {
60
+
return Err(anyhow::anyhow!(
61
+
"digest of {spec:?} did not match {digest:?}! Please create an issue!"
62
+
));
63
+
}
64
+
65
+
let path = PathBuf::from(&spec.destination);
66
+
create_path(&path)?;
67
+
68
+
let mut file = File::create(path).await?;
69
+
let mut permissions = file.metadata().await?.permissions();
70
+
71
+
permissions.set_mode(spec.unix_mode);
72
+
file.set_permissions(permissions).await?;
73
+
74
+
let user = User::from_name(&spec.user)?;
75
+
let group = Group::from_name(&spec.group)?;
76
+
77
+
chown(
78
+
spec.destination,
79
+
// Default uid/gid to 0. This is then wrapped around an Option again for
80
+
// the function.
81
+
Some(user.map_or(0, |user| user.uid.into())),
82
+
Some(group.map_or(0, |group| group.gid.into())),
83
+
)?;
84
+
85
+
file.write_all(&key_bytes).await?;
86
+
87
+
// last key, goobye
88
+
if spec.last {
89
+
break;
90
+
}
91
+
}
92
+
93
+
Ok(())
94
+
}
+158
-164
doc/.vitepress/config.ts
+158
-164
doc/.vitepress/config.ts
···
1
1
import { defineConfig } from "vitepress";
2
2
import pkg from "../package.json";
3
3
import markdownItFootnote from "markdown-it-footnote";
4
-
import { withMermaid } from "vitepress-plugin-mermaid";
5
4
import {
6
5
groupIconMdPlugin,
7
6
groupIconVitePlugin,
···
11
10
const MODE = (process.env.MODE ?? "unstable") as "unstable" | "stable";
12
11
13
12
// https://vitepress.dev/reference/site-config
14
-
export default withMermaid(
15
-
defineConfig({
16
-
title: MODE === "stable" ? "wire" : "wire (unstable!)",
17
-
description: "a tool to deploy nixos systems",
18
-
themeConfig: {
19
-
search: {
20
-
provider: "local",
21
-
},
13
+
export default defineConfig({
14
+
title: MODE === "stable" ? "wire" : "wire (unstable!)",
15
+
description: "a tool to deploy nixos systems",
16
+
themeConfig: {
17
+
search: {
18
+
provider: "local",
19
+
},
20
+
21
+
footer: {
22
+
message:
23
+
'Released under the <a href="https://github.com/forallsys/wire/blob/trunk/COPYING">AGPL-3.0 License</a>.',
24
+
copyright: "Copyright 2024-2025 wire Contributors",
25
+
},
22
26
23
-
footer: {
24
-
message:
25
-
'Released under the <a href="https://github.com/mrshmllow/wire/blob/trunk/COPYING">AGPL-3.0 License</a>.',
26
-
copyright: "Copyright 2024-2025 wire Contributors",
27
+
// https://vitepress.dev/reference/default-theme-config
28
+
nav: [
29
+
{ text: "Home", link: "/" },
30
+
{ text: "Tutorial", link: "/tutorial/overview" },
31
+
{ text: "Guides", link: "/guides/installation" },
32
+
{ text: "Reference", link: "/reference/cli" },
33
+
{
34
+
text: MODE === "stable" ? pkg.version : `Unstable (${pkg.version})`,
35
+
items: [
36
+
MODE === "unstable"
37
+
? {
38
+
text: `View Stable`,
39
+
link: "https://wire.althaea.zone",
40
+
}
41
+
: {
42
+
text: "View Unstable",
43
+
link: "https://trunk.wire-docs.pages.dev",
44
+
},
45
+
{
46
+
text: "Changelog",
47
+
link: "https://github.com/forallsys/wire/blob/trunk/CHANGELOG.md",
48
+
},
49
+
{
50
+
text: "CI Server",
51
+
link: "https://buildbot.althaea.zone/#/projects/1",
52
+
},
53
+
],
27
54
},
55
+
],
28
56
29
-
// https://vitepress.dev/reference/default-theme-config
30
-
nav: [
31
-
{ text: "Home", link: "/" },
32
-
{ text: "Tutorial", link: "/tutorial/overview" },
33
-
{ text: "Guides", link: "/guides/installation" },
34
-
{ text: "Reference", link: "/reference/cli" },
57
+
sidebar: {
58
+
"/": [
35
59
{
36
-
text: MODE === "stable" ? pkg.version : "Unstable",
60
+
text: "Tutorial",
61
+
collapsed: false,
37
62
items: [
38
-
MODE === "unstable"
39
-
? {
40
-
text: `View ${pkg.version}`,
41
-
link: "https://wire.althaea.zone",
42
-
}
43
-
: {
44
-
text: "View Unstable",
45
-
link: "https://trunk.wire-docs.pages.dev",
63
+
{ text: "Overview", link: "/tutorial/overview" },
64
+
{
65
+
text: "Part One",
66
+
items: [
67
+
{
68
+
text: "Nix Setup",
69
+
link: "/tutorial/part-one/nix-setup",
70
+
},
71
+
{
72
+
text: "Preparing Repo & Shell",
73
+
link: "/tutorial/part-one/repo-setup",
74
+
},
75
+
{
76
+
text: "Creating a Virtual Machine",
77
+
link: "/tutorial/part-one/vm-setup",
78
+
},
79
+
{
80
+
text: "Basic Hive & Deployment",
81
+
link: "/tutorial/part-one/basic-hive",
46
82
},
83
+
],
84
+
},
47
85
{
48
-
text: "Changelog",
49
-
link: "https://github.com/mrshmllow/wire/blob/trunk/CHANGELOG.md",
86
+
text: "Part Two",
87
+
items: [
88
+
{
89
+
text: "Basic Deployment Keys",
90
+
link: "/tutorial/part-two/basic-keys",
91
+
},
92
+
{
93
+
text: "Encrypted Deployment Keys",
94
+
link: "/tutorial/part-two/encryption",
95
+
},
96
+
],
50
97
},
98
+
],
99
+
},
100
+
{
101
+
text: "How-To Guides",
102
+
collapsed: false,
103
+
items: [
104
+
{ text: "Install wire", link: "/guides/installation" },
51
105
{
52
-
text: "CI Server",
53
-
link: "https://buildbot.althaea.zone/#/projects/1",
106
+
text: "Write a Hive",
107
+
link: "/guides/writing-a-hive",
108
+
},
109
+
{ text: "Migrate to wire", link: "/guides/migrate" },
110
+
{
111
+
text: "Use Flakes",
112
+
link: "/guides/flakes/overview",
113
+
items: [
114
+
{
115
+
text: "Keep Using nixos-rebuild",
116
+
link: "/guides/flakes/nixos-rebuild",
117
+
},
118
+
],
119
+
},
120
+
{ text: "Apply your Config", link: "/guides/apply" },
121
+
{ text: "Target Nodes", link: "/guides/targeting" },
122
+
{ text: "Build in CI", link: "/guides/build-in-ci" },
123
+
{
124
+
text: "Features",
125
+
items: [
126
+
{
127
+
text: "Use a non-root user",
128
+
link: "/guides/non-root-user",
129
+
},
130
+
{ text: "Manage Secrets", link: "/guides/keys" },
131
+
{ text: "Use Parallelism", link: "/guides/parallelism" },
132
+
{ text: "Use hive.default", link: "/guides/hive-default" },
133
+
],
54
134
},
55
135
],
56
136
},
137
+
{ text: "CLI & Module Reference", link: "/reference/cli.html" },
57
138
],
58
-
59
-
sidebar: {
60
-
"/": [
61
-
{
62
-
text: "Tutorial",
63
-
collapsed: false,
64
-
items: [
65
-
{ text: "Overview", link: "/tutorial/overview" },
66
-
{
67
-
text: "Part One",
68
-
items: [
69
-
{
70
-
text: "Nix Setup",
71
-
link: "/tutorial/part-one/nix-setup",
72
-
},
73
-
{
74
-
text: "Preparing Repo & Shell",
75
-
link: "/tutorial/part-one/repo-setup",
76
-
},
77
-
{
78
-
text: "Creating a Virtual Machine",
79
-
link: "/tutorial/part-one/vm-setup",
80
-
},
81
-
{
82
-
text: "Basic Hive & Deployment",
83
-
link: "/tutorial/part-one/basic-hive",
84
-
},
85
-
],
86
-
},
87
-
{
88
-
text: "Part Two",
89
-
items: [
90
-
{
91
-
text: "Basic Deployment Keys",
92
-
link: "/tutorial/part-two/basic-keys",
93
-
},
94
-
{
95
-
text: "Encrypted Deployment Keys",
96
-
link: "/tutorial/part-two/encryption",
97
-
},
98
-
],
99
-
},
100
-
],
101
-
},
102
-
{
103
-
text: "How-To Guides",
104
-
collapsed: false,
105
-
items: [
106
-
{ text: "Install wire", link: "/guides/installation" },
107
-
{
108
-
text: "Write a Hive",
109
-
link: "/guides/writing-a-hive",
110
-
},
111
-
{ text: "Migrate to wire", link: "/guides/migrate" },
112
-
{
113
-
text: "Use Flakes",
114
-
link: "/guides/flakes/overview",
115
-
items: [
116
-
{
117
-
text: "Keep Using nixos-rebuild",
118
-
link: "/guides/flakes/nixos-rebuild",
119
-
},
120
-
],
121
-
},
122
-
{ text: "Apply your Config", link: "/guides/apply" },
123
-
{ text: "Target Nodes", link: "/guides/targeting" },
124
-
{
125
-
text: "Features",
126
-
items: [
127
-
{
128
-
text: "Use a non-root user",
129
-
link: "/guides/non-root-user",
130
-
},
131
-
{ text: "Manage Secrets", link: "/guides/keys" },
132
-
{ text: "Use Parallelism", link: "/guides/parallelism" },
133
-
{ text: "Use hive.default", link: "/guides/hive-default" },
134
-
],
135
-
},
136
-
],
137
-
},
138
-
{ text: "CLI & Module Reference", link: "/reference/cli.html" },
139
-
],
140
-
"/reference/": [
141
-
{
142
-
text: "Reference",
143
-
items: [
144
-
{ text: "CLI", link: "/reference/cli" },
145
-
{ text: "Meta Options", link: "/reference/meta" },
146
-
{ text: "Module Options", link: "/reference/module" },
147
-
{ text: "Error Codes", link: "/reference/errors" },
148
-
],
149
-
},
150
-
],
151
-
},
152
-
153
-
editLink: {
154
-
pattern: "https://github.com/mrshmllow/wire/edit/trunk/doc/:path",
155
-
text: "Edit this page on GitHub",
156
-
},
157
-
158
-
socialLinks: [
159
-
{ icon: "github", link: "https://github.com/mrshmllow/wire" },
139
+
"/reference/": [
140
+
{
141
+
text: "Reference",
142
+
items: [
143
+
{ text: "CLI", link: "/reference/cli" },
144
+
{ text: "Meta Options", link: "/reference/meta" },
145
+
{ text: "Module Options", link: "/reference/module" },
146
+
{ text: "Error Codes", link: "/reference/errors" },
147
+
],
148
+
},
160
149
],
161
150
},
162
-
markdown: {
163
-
config: (md) => {
164
-
md.use(markdownItFootnote);
165
-
md.use(groupIconMdPlugin, {
166
-
titleBar: { includeSnippet: true },
167
-
});
168
-
},
151
+
152
+
editLink: {
153
+
pattern: "https://github.com/forallsys/wire/edit/trunk/doc/:path",
154
+
text: "Edit this page on GitHub",
169
155
},
170
-
vite: {
171
-
// https://github.com/mermaid-js/mermaid/issues/4320#issuecomment-1653050539
172
-
optimizeDeps: {
173
-
include: ["mermaid"],
174
-
},
175
-
plugins: [
176
-
groupIconVitePlugin({
177
-
customIcon: {
178
-
nixos: "vscode-icons:file-type-nix",
179
-
"configuration.nix": "vscode-icons:file-type-nix",
180
-
"hive.nix": "vscode-icons:file-type-nix",
181
-
"flake.nix": "vscode-icons:file-type-nix",
182
-
"module.nix": "vscode-icons:file-type-nix",
183
-
"vm.nix": "vscode-icons:file-type-nix",
184
-
"shell.nix": "vscode-icons:file-type-nix",
185
-
"secrets.nix": "vscode-icons:file-type-nix",
186
-
home: localIconLoader(import.meta.url, "../assets/homemanager.svg"),
187
-
".conf": "vscode-icons:file-type-config",
188
-
},
189
-
}),
190
-
],
156
+
157
+
socialLinks: [
158
+
{ icon: "github", link: "https://github.com/forallsys/wire" },
159
+
],
160
+
},
161
+
markdown: {
162
+
config: (md) => {
163
+
md.use(markdownItFootnote);
164
+
md.use(groupIconMdPlugin, {
165
+
titleBar: { includeSnippet: true },
166
+
});
191
167
},
192
-
}),
193
-
);
168
+
},
169
+
vite: {
170
+
plugins: [
171
+
groupIconVitePlugin({
172
+
customIcon: {
173
+
nixos: "vscode-icons:file-type-nix",
174
+
"configuration.nix": "vscode-icons:file-type-nix",
175
+
"hive.nix": "vscode-icons:file-type-nix",
176
+
"flake.nix": "vscode-icons:file-type-nix",
177
+
"module.nix": "vscode-icons:file-type-nix",
178
+
"vm.nix": "vscode-icons:file-type-nix",
179
+
"shell.nix": "vscode-icons:file-type-nix",
180
+
"secrets.nix": "vscode-icons:file-type-nix",
181
+
home: localIconLoader(import.meta.url, "../assets/homemanager.svg"),
182
+
".conf": "vscode-icons:file-type-config",
183
+
},
184
+
}),
185
+
],
186
+
},
187
+
});
+1
-34
doc/.vitepress/theme/index.ts
+1
-34
doc/.vitepress/theme/index.ts
···
1
1
import DefaultTheme from "vitepress/theme";
2
2
import "virtual:group-icons.css";
3
-
import giscusTalk from "vitepress-plugin-comment-with-giscus";
4
-
import { EnhanceAppContext, useData, useRoute } from "vitepress";
5
-
import { toRefs } from "vue";
3
+
import { EnhanceAppContext } from "vitepress";
6
4
import "./style.css";
7
5
8
6
export default {
9
7
...DefaultTheme,
10
8
enhanceApp(ctx: EnhanceAppContext) {
11
9
DefaultTheme.enhanceApp(ctx);
12
-
},
13
-
setup() {
14
-
const { frontmatter } = toRefs(useData());
15
-
const route = useRoute();
16
-
17
-
giscusTalk(
18
-
{
19
-
repo: "mrshmllow/wire",
20
-
repoId: "R_kgDOMQQbzw",
21
-
category: "giscus", // default: `General`
22
-
categoryId: "DIC_kwDOMQQbz84Co4vv",
23
-
mapping: "pathname",
24
-
inputPosition: "top",
25
-
lang: "en",
26
-
// i18n setting (Note: This configuration will override the default language set by lang)
27
-
// Configured as an object with key-value pairs inside:
28
-
// [your i18n configuration name]: [corresponds to the language pack name in Giscus]
29
-
locales: {
30
-
"en-US": "en",
31
-
},
32
-
homePageShowComment: false,
33
-
lightTheme: "light",
34
-
darkTheme: "transparent_dark",
35
-
},
36
-
{
37
-
frontmatter,
38
-
route,
39
-
},
40
-
// Default to false for all pages
41
-
false,
42
-
);
43
10
},
44
11
};
+1
-34
doc/guides/apply.md
+1
-34
doc/guides/apply.md
···
4
4
description: How to apply a node with wire.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Apply your Config
8
8
9
9
{{ $frontmatter.description }}
10
10
···
28
28
29
29
Which will `switch` to each node's NixOS system in your hive and push
30
30
secrets (the equivalent to `nixos-rebuild`'s `nixos-rebuild switch`).
31
-
32
-
::: details Apply Goal Flowchart
33
-
The following is an illustrative flowchart of how each step in the apply execution is ran.
34
-
35
-
Depending on the specific goal certain steps will not run, for example the
36
-
Switch to Configuration step will never run if the goal is `build`.
37
-
38
-
```mermaid
39
-
flowchart TD
40
-
A(Test Connection) --> |IP / Hostname| B(Push Keys)
41
-
42
-
C(Evaluate NixOS System)
43
-
44
-
B --> C
45
-
C -->|.drv Path| local
46
-
C -->|.drv Path| remote
47
-
48
-
subgraph remote[Remote Node]
49
-
D(Push To Node)
50
-
D --> E(Build NixOS System)
51
-
E -->|Built System| H(Push To Node)
52
-
end
53
-
54
-
subgraph local[Local Node]
55
-
direction RL
56
-
G(Build NixOS System Locally)
57
-
end
58
-
59
-
G --> F(Switch To Configuration)
60
-
H --> F
61
-
```
62
-
63
-
:::
64
31
65
32
## Apply goals
66
33
+36
doc/guides/build-in-ci.md
+36
doc/guides/build-in-ci.md
···
1
+
---
2
+
comment: true
3
+
title: Build in CI
4
+
---
5
+
6
+
# Build in CI
7
+
8
+
## The `wire build` command <Badge type="tip" text="^1.1.0" />
9
+
10
+
`wire build` builds nodes locally. It is distinct from
11
+
`wire apply build`, as it will not ping or push the result,
12
+
making it useful for CI.
13
+
14
+
It accepts the same `--on` argument as `wire apply` does.
15
+
16
+
## Partitioning builds
17
+
18
+
`wire build` accepts a `--partition` option inspired by
19
+
[cargo-nextest](https://nexte.st/docs/ci-features/partitioning/), which splits
20
+
selected nodes into buckets to be built separately.
21
+
22
+
It accepts values in the format `--partition current/total`, where 1 โค current โค total.
23
+
24
+
For example, these two commands will build the entire hive in two invocations:
25
+
26
+
```sh
27
+
wire build --partition 1/2
28
+
29
+
# later or synchronously:
30
+
31
+
wire build --partition 2/2
32
+
```
33
+
34
+
## Example: Build in Github Actions
35
+
36
+
<<< @/snippets/guides/example-action.yml [.github/workflows/build.yml]
+1
-1
doc/guides/flakes/nixos-rebuild.md
+1
-1
doc/guides/flakes/nixos-rebuild.md
+1
-1
doc/guides/flakes/overview.md
+1
-1
doc/guides/flakes/overview.md
+1
-1
doc/guides/hive-default.md
+1
-1
doc/guides/hive-default.md
+10
-6
doc/guides/installation.md
+10
-6
doc/guides/installation.md
···
4
4
description: How to install wire tool.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Install wire
8
8
9
9
{{ $frontmatter.description }}
10
10
···
19
19
20
20
## Binary Cache
21
21
22
-
You should enable the [garnix binary cache](https://garnix.io/docs/caching).
22
+
You should enable the [garnix binary cache](https://garnix.io/docs/caching) _before_
23
+
continuing otherwise you will be compiling from source:
24
+
25
+
::: code-group
26
+
<<< @/snippets/tutorial/cache.conf [nix.conf]
27
+
<<< @/snippets/tutorial/cache.nix [configuration.nix]
28
+
:::
23
29
24
30
## Installation through flakes
25
31
···
39
45
you'd like, really.
40
46
41
47
```sh
42
-
$ npins add github mrshmllow wire --branch stable
48
+
$ npins add github forallsys wire --branch stable
43
49
```
44
50
45
51
Alternatively, you can use a tag instead:
46
52
47
53
```sh
48
-
$ npins add github mrshmllow wire --at v1.0.0-beta.0
54
+
$ npins add github forallsys wire --at v1.1.1
49
55
```
50
56
51
57
Then, use this pinned version of wire for both your `hive.nix` and `shell.nix`:
52
58
53
-
::: code-group
54
59
<<< @/snippets/guides/installation/shell.nix{8} [shell.nix]
55
60
<<< @/snippets/guides/installation/hive.nix [hive.nix]
56
-
:::
+2
-2
doc/guides/keys.md
+2
-2
doc/guides/keys.md
···
4
4
description: Manage keys, secrets, files, and other out-of-store paths with wire Tool.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Manage Secrets
8
8
9
9
{{ $frontmatter.description }}
10
10
···
38
38
Otherwise, you may see errors such as:
39
39
40
40
```
41
-
error: cannot add path '/nix/store/...-wire-tool-agent-x86_64-linux-...' because it lacks a signature by a trusted key
41
+
error: cannot add path '/nix/store/...-wire-tool-key_agent-x86_64-linux-...' because it lacks a signature by a trusted key
42
42
```
43
43
44
44
This is a requirement because `nix copy` is used to copy the binary.
+2
-2
doc/guides/migrate.md
+2
-2
doc/guides/migrate.md
···
4
4
description: How-to migrate from other tools to wire tool.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Migrate to wire
8
8
9
9
{{ $frontmatter.description }}
10
10
···
41
41
inputs = {
42
42
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
43
43
colmena.url = "github:zhaofengli/colmena"; # [!code --]
44
-
wire.url = "github:mrshmllow/wire/stable"; # [!code ++]
44
+
wire.url = "github:forallsys/wire/stable"; # [!code ++]
45
45
};
46
46
outputs =
47
47
{ nixpkgs, colmena, ... }:
+15
-16
doc/guides/non-root-user.md
+15
-16
doc/guides/non-root-user.md
···
4
4
description: Deploy without root permissions with wire.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Use a non-root user
8
8
9
9
{{ $frontmatter.description }}
10
10
11
11
## Deploying User Requirements
12
12
13
-
If your selected deployment user does not fit the following requirements, the
14
-
deployment commands will likely fail with an error:
13
+
For deployment commands to succeed, the user defined in `deployment.target.user` must meet the following criteria:
14
+
15
+
1. Essential Config
16
+
17
+
- **Sudo Access**: The user must be `wheel` (A sudo user)
18
+
- **SSH Key Authentication**: The user must be authenticated through SSH keys,
19
+
and password-based SSH auth is not supported.
20
+
21
+
**Why?** Wire can prompt you for your `sudo` password, but not your `ssh` password.
15
22
16
-
| `deployment.target.user` has/is... | โ Will Not Work | ๐ง Deploys w/o Keys | โ
Deploys w/ Keys |
17
-
| :--------------------------------- | :--------------: | :-----------------: | :----------------: |
18
-
| In `wheel` (Sudo User) | No | Yes | Yes |
19
-
| Has Non-Interactive SSH Auth | - | Yes | Yes |
20
-
| A Trusted User | - | No | Yes |
23
+
2. Deploying with Secrets
21
24
22
-
When using a non-trusted user, `wire apply` will likely fail if the deploying user is
23
-
not trusted, see [Manage Secrets - Prerequisites](/guides/keys.html#prerequisites).
25
+
- **Trusted User**: The user must be listed in the `trusted-users` nix config.
24
26
25
-
- "In `wheel`" here meaning a sudoer, whether it be `root` or not.
26
-
- "Non-interactive SSH Auth" here most likely meaning an SSH key, anything that
27
-
does not require keyboard input in the terminal.
27
+
If the user is not trusted, wire will fail in the key deployment stage.
28
28
29
-
To put it simply, wire can currently prompt for your password on `sudo`,
30
-
but not `ssh`.
29
+
For setting up a trusted user, see [Manage Secrets - Prerequisites](/guides/keys.html#prerequisites).
31
30
32
31
## Changing the user
33
32
···
56
55
INFO eval_hive: evaluating hive Flake("/path/to/hive")
57
56
...
58
57
INFO media | step="Upload key @ NoFilter" progress="3/4"
59
-
deploy-user@node:22 | Authenticate for "sudo /nix/store/.../bin/agent":
58
+
deploy-user@node:22 | Authenticate for "sudo /nix/store/.../bin/key_agent":
60
59
[sudo] password for deploy-user:
61
60
```
62
61
+1
-1
doc/guides/parallelism.md
+1
-1
doc/guides/parallelism.md
+1
-1
doc/guides/targeting.md
+1
-1
doc/guides/targeting.md
+25
-25
doc/guides/writing-a-hive.md
+25
-25
doc/guides/writing-a-hive.md
···
3
3
title: Write a Hive
4
4
---
5
5
6
-
# {{ $frontmatter.title }}
6
+
# Write a Hive
7
7
8
8
## Anatomy of a Hive
9
9
···
11
11
following layout:
12
12
13
13
```nix
14
-
# `meta`
15
-
# type: attrset
16
-
meta = {
17
-
# `meta.nixpkgs` tells wire how to get nixpkgs.
18
-
# type: "A path or an instance of nixpkgs."
19
-
nixpkgs = <nixpkgs>;
20
-
21
-
# `meta.specialArgs` are specialArgs to pass to each node & default
14
+
wire.makeHive {
15
+
# `meta`
22
16
# type: attrset
23
-
specialArgs = { };
17
+
meta = {
18
+
# `meta.nixpkgs` tells wire how to get nixpkgs.
19
+
# type: "A path or an instance of nixpkgs."
20
+
nixpkgs = <nixpkgs>;
24
21
25
-
# `meta.nodeNixpkgs` lets you override nixpkgs per-node.
26
-
# type: attrset of "A path or an instance of nixpkgs."
27
-
nodeNixpkgs: = { };
28
-
};
22
+
# `meta.specialArgs` are specialArgs to pass to each node & default
23
+
# type: attrset
24
+
specialArgs = { };
29
25
30
-
# `defaults` is a module applied to every node
31
-
# type: NixOS Module
32
-
defaults = { ... }: { };
26
+
# `meta.nodeSpecialArgs` lets you override `meta.specialArgs` per-node.
27
+
# type: attrset of attrset
28
+
nodeSpecialArgs: = { };
33
29
34
-
# Any other attributes are nodes.
30
+
# `meta.nodeNixpkgs` lets you override nixpkgs per-node.
31
+
# type: attrset of "A path or an instance of nixpkgs."
32
+
nodeNixpkgs: = { };
33
+
};
34
+
35
+
# `defaults` is a module applied to every node
36
+
# type: NixOS Module
37
+
defaults = { ... }: { };
38
+
39
+
# Any other attributes are nodes.
40
+
<node-name> = { ... }: { };
41
+
}
35
42
```
36
43
37
44
### `<node-name>`
···
52
59
53
60
At the top level of a hive wire reserves the `defaults` attribute. It's applied
54
61
to every node.
55
-
56
-
::: warning
57
-
58
-
`defaults` must not rely on modules that a node imports, but a
59
-
node may rely on modules that default imports.
60
-
61
-
:::
62
62
63
63
## Example
64
64
+1
-1
doc/index.md
+1
-1
doc/index.md
+2
-5
doc/package.json
+2
-5
doc/package.json
···
1
1
{
2
2
"name": "wire-docs",
3
-
"version": "1.0.0-beta.0",
3
+
"version": "1.1.1",
4
4
"type": "module",
5
5
"devDependencies": {
6
-
"mermaid": "^11.12.1",
7
6
"vitepress": "^1.6.4",
8
-
"vitepress-plugin-mermaid": "^2.0.17",
9
-
"vue": "^3.5.22"
7
+
"vue": "^3.5.25"
10
8
},
11
9
"scripts": {
12
10
"dev": "vitepress dev .",
···
20
18
},
21
19
"dependencies": {
22
20
"markdown-it-footnote": "^4.0.0",
23
-
"vitepress-plugin-comment-with-giscus": "^1.1.15",
24
21
"vitepress-plugin-group-icons": "^1.6.5"
25
22
}
26
23
}
+1
-1
doc/package.nix
+1
-1
doc/package.nix
···
52
52
pnpmDeps = pnpm.fetchDeps {
53
53
inherit (finalAttrs) pname version src;
54
54
fetcherVersion = 1;
55
-
hash = "sha256-S2DCxkBeQ4qz4af53k8mqU223PCSGSVFh0l0qoo7uVw=";
55
+
hash = "sha256-ydgb5NCFsYaDbmLjBqu91MqKj/I3TKpNLjOvyP+aY8o=";
56
56
};
57
57
patchPhase = ''
58
58
cat ${optionsDoc} >> ./reference/module.md
+368
-1430
doc/pnpm-lock.yaml
+368
-1430
doc/pnpm-lock.yaml
···
11
11
markdown-it-footnote:
12
12
specifier: ^4.0.0
13
13
version: 4.0.0
14
-
vitepress-plugin-comment-with-giscus:
15
-
specifier: ^1.1.15
16
-
version: 1.1.15(vue@3.5.25)
17
14
vitepress-plugin-group-icons:
18
15
specifier: ^1.6.5
19
-
version: 1.6.5(vite@5.4.20)
16
+
version: 1.6.5(vite@5.4.21)
20
17
devDependencies:
21
-
mermaid:
22
-
specifier: ^11.12.1
23
-
version: 11.12.2
24
18
vitepress:
25
19
specifier: ^1.6.4
26
-
version: 1.6.4(@algolia/client-search@5.40.0)(postcss@8.5.6)(search-insights@2.17.3)
27
-
vitepress-plugin-mermaid:
28
-
specifier: ^2.0.17
29
-
version: 2.0.17(mermaid@11.12.2)(vitepress@1.6.4(@algolia/client-search@5.40.0)(postcss@8.5.6)(search-insights@2.17.3))
20
+
version: 1.6.4(@algolia/client-search@5.46.0)(postcss@8.5.6)(search-insights@2.17.3)
30
21
vue:
31
-
specifier: ^3.5.22
32
-
version: 3.5.25
22
+
specifier: ^3.5.25
23
+
version: 3.5.26
33
24
34
25
packages:
35
26
36
-
'@algolia/abtesting@1.6.0':
37
-
resolution: {integrity: sha512-c4M/Z/KWkEG+RHpZsWKDTTlApXu3fe4vlABNcpankWBhdMe4oPZ/r4JxEr2zKUP6K+BT66tnp8UbHmgOd/vvqQ==}
27
+
'@algolia/abtesting@1.12.0':
28
+
resolution: {integrity: sha512-EfW0bfxjPs+C7ANkJDw2TATntfBKsFiy7APh+KO0pQ8A6HYa5I0NjFuCGCXWfzzzLXNZta3QUl3n5Kmm6aJo9Q==}
38
29
engines: {node: '>= 14.0.0'}
39
30
40
31
'@algolia/autocomplete-core@1.17.7':
···
57
48
'@algolia/client-search': '>= 4.9.1 < 6'
58
49
algoliasearch: '>= 4.9.1 < 6'
59
50
60
-
'@algolia/client-abtesting@5.40.0':
61
-
resolution: {integrity: sha512-qegVlgHtmiS8m9nEsuKUVhlw1FHsIshtt5nhNnA6EYz3g+tm9+xkVZZMzkrMLPP7kpoheHJZAwz2MYnHtwFa9A==}
51
+
'@algolia/client-abtesting@5.46.0':
52
+
resolution: {integrity: sha512-eG5xV8rujK4ZIHXrRshvv9O13NmU/k42Rnd3w43iKH5RaQ2zWuZO6Q7XjaoJjAFVCsJWqRbXzbYyPGrbF3wGNg==}
62
53
engines: {node: '>= 14.0.0'}
63
54
64
-
'@algolia/client-analytics@5.40.0':
65
-
resolution: {integrity: sha512-Dw2c+6KGkw7mucnnxPyyMsIGEY8+hqv6oB+viYB612OMM3l8aNaWToBZMnNvXsyP+fArwq7XGR+k3boPZyV53A==}
55
+
'@algolia/client-analytics@5.46.0':
56
+
resolution: {integrity: sha512-AYh2uL8IUW9eZrbbT+wZElyb7QkkeV3US2NEKY7doqMlyPWE8lErNfkVN1NvZdVcY4/SVic5GDbeDz2ft8YIiQ==}
66
57
engines: {node: '>= 14.0.0'}
67
58
68
-
'@algolia/client-common@5.40.0':
69
-
resolution: {integrity: sha512-dbE4+MJIDsTghG3hUYWBq7THhaAmqNqvW9g2vzwPf5edU4IRmuYpKtY3MMotes8/wdTasWG07XoaVhplJBlvdg==}
59
+
'@algolia/client-common@5.46.0':
60
+
resolution: {integrity: sha512-0emZTaYOeI9WzJi0TcNd2k3SxiN6DZfdWc2x2gHt855Jl9jPUOzfVTL6gTvCCrOlT4McvpDGg5nGO+9doEjjig==}
70
61
engines: {node: '>= 14.0.0'}
71
62
72
-
'@algolia/client-insights@5.40.0':
73
-
resolution: {integrity: sha512-SH6zlROyGUCDDWg71DlCnbbZ/zEHYPZC8k901EAaBVhvY43Ju8Wa6LAcMPC4tahcDBgkG2poBy8nJZXvwEWAlQ==}
63
+
'@algolia/client-insights@5.46.0':
64
+
resolution: {integrity: sha512-wrBJ8fE+M0TDG1As4DDmwPn2TXajrvmvAN72Qwpuv8e2JOKNohF7+JxBoF70ZLlvP1A1EiH8DBu+JpfhBbNphQ==}
74
65
engines: {node: '>= 14.0.0'}
75
66
76
-
'@algolia/client-personalization@5.40.0':
77
-
resolution: {integrity: sha512-EgHjJEEf7CbUL9gJHI1ULmAtAFeym2cFNSAi1uwHelWgLPcnLjYW2opruPxigOV7NcetkGu+t2pcWOWmZFuvKQ==}
67
+
'@algolia/client-personalization@5.46.0':
68
+
resolution: {integrity: sha512-LnkeX4p0ENt0DoftDJJDzQQJig/sFQmD1eQifl/iSjhUOGUIKC/7VTeXRcKtQB78naS8njUAwpzFvxy1CDDXDQ==}
78
69
engines: {node: '>= 14.0.0'}
79
70
80
-
'@algolia/client-query-suggestions@5.40.0':
81
-
resolution: {integrity: sha512-HvE1jtCag95DR41tDh7cGwrMk4X0aQXPOBIhZRmsBPolMeqRJz0kvfVw8VCKvA1uuoAkjFfTG0X0IZED+rKXoA==}
71
+
'@algolia/client-query-suggestions@5.46.0':
72
+
resolution: {integrity: sha512-aF9tc4ex/smypXw+W3lBPB1jjKoaGHpZezTqofvDOI/oK1dR2sdTpFpK2Ru+7IRzYgwtRqHF3znmTlyoNs9dpA==}
82
73
engines: {node: '>= 14.0.0'}
83
74
84
-
'@algolia/client-search@5.40.0':
85
-
resolution: {integrity: sha512-nlr/MMgoLNUHcfWC5Ns2ENrzKx9x51orPc6wJ8Ignv1DsrUmKm0LUih+Tj3J+kxYofzqQIQRU495d4xn3ozMbg==}
75
+
'@algolia/client-search@5.46.0':
76
+
resolution: {integrity: sha512-22SHEEVNjZfFWkFks3P6HilkR3rS7a6GjnCIqR22Zz4HNxdfT0FG+RE7efTcFVfLUkTTMQQybvaUcwMrHXYa7Q==}
86
77
engines: {node: '>= 14.0.0'}
87
78
88
-
'@algolia/ingestion@1.40.0':
89
-
resolution: {integrity: sha512-OfHnhE+P0f+p3i90Kmshf9Epgesw5oPV1IEUOY4Mq1HV7cQk16gvklVN1EaY/T9sVavl+Vc3g4ojlfpIwZFA4g==}
79
+
'@algolia/ingestion@1.46.0':
80
+
resolution: {integrity: sha512-2LT0/Z+/sFwEpZLH6V17WSZ81JX2uPjgvv5eNlxgU7rPyup4NXXfuMbtCJ+6uc4RO/LQpEJd3Li59ke3wtyAsA==}
90
81
engines: {node: '>= 14.0.0'}
91
82
92
-
'@algolia/monitoring@1.40.0':
93
-
resolution: {integrity: sha512-SWANV32PTKhBYvwKozeWP9HOnVabOixAuPdFFGoqtysTkkwutrtGI/rrh80tvG+BnQAmZX0vUmD/RqFZVfr/Yg==}
83
+
'@algolia/monitoring@1.46.0':
84
+
resolution: {integrity: sha512-uivZ9wSWZ8mz2ZU0dgDvQwvVZV8XBv6lYBXf8UtkQF3u7WeTqBPeU8ZoeTyLpf0jAXCYOvc1mAVmK0xPLuEwOQ==}
94
85
engines: {node: '>= 14.0.0'}
95
86
96
-
'@algolia/recommend@5.40.0':
97
-
resolution: {integrity: sha512-1Qxy9I5bSb3mrhPk809DllMa561zl5hLsMR6YhIqNkqQ0OyXXQokvJ2zApSxvd39veRZZnhN+oGe+XNoNwLgkw==}
87
+
'@algolia/recommend@5.46.0':
88
+
resolution: {integrity: sha512-O2BB8DuySuddgOAbhyH4jsGbL+KyDGpzJRtkDZkv091OMomqIA78emhhMhX9d/nIRrzS1wNLWB/ix7Hb2eV5rg==}
98
89
engines: {node: '>= 14.0.0'}
99
90
100
-
'@algolia/requester-browser-xhr@5.40.0':
101
-
resolution: {integrity: sha512-MGt94rdHfkrVjfN/KwUfWcnaeohYbWGINrPs96f5J7ZyRYpVLF+VtPQ2FmcddFvK4gnKXSu8BAi81hiIhUpm3w==}
91
+
'@algolia/requester-browser-xhr@5.46.0':
92
+
resolution: {integrity: sha512-eW6xyHCyYrJD0Kjk9Mz33gQ40LfWiEA51JJTVfJy3yeoRSw/NXhAL81Pljpa0qslTs6+LO/5DYPZddct6HvISQ==}
102
93
engines: {node: '>= 14.0.0'}
103
94
104
-
'@algolia/requester-fetch@5.40.0':
105
-
resolution: {integrity: sha512-wXQ05JZZ10Dr642QVAkAZ4ZZlU+lh5r6dIBGmm9WElz+1EaQ6BNYtEOTV6pkXuFYsZpeJA89JpDOiwBOP9j24w==}
95
+
'@algolia/requester-fetch@5.46.0':
96
+
resolution: {integrity: sha512-Vn2+TukMGHy4PIxmdvP667tN/MhS7MPT8EEvEhS6JyFLPx3weLcxSa1F9gVvrfHWCUJhLWoMVJVB2PT8YfRGcw==}
106
97
engines: {node: '>= 14.0.0'}
107
98
108
-
'@algolia/requester-node-http@5.40.0':
109
-
resolution: {integrity: sha512-5qCRoySnzpbQVg2IPLGFCm4LF75pToxI5tdjOYgUMNL/um91aJ4dH3SVdBEuFlVsalxl8mh3bWPgkUmv6NpJiQ==}
99
+
'@algolia/requester-node-http@5.46.0':
100
+
resolution: {integrity: sha512-xaqXyna5yBZ+r1SJ9my/DM6vfTqJg9FJgVydRJ0lnO+D5NhqGW/qaRG/iBGKr/d4fho34el6WakV7BqJvrl/HQ==}
110
101
engines: {node: '>= 14.0.0'}
111
102
112
103
'@antfu/install-pkg@1.1.0':
113
104
resolution: {integrity: sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==}
114
105
115
-
'@antfu/utils@9.3.0':
116
-
resolution: {integrity: sha512-9hFT4RauhcUzqOE4f1+frMKLZrgNog5b06I7VmZQV1BkvwvqrbC8EBZf3L1eEL2AKb6rNKjER0sEvJiSP1FXEA==}
117
-
118
106
'@babel/helper-string-parser@7.27.1':
119
107
resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
120
108
engines: {node: '>=6.9.0'}
···
131
119
'@babel/types@7.28.5':
132
120
resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
133
121
engines: {node: '>=6.9.0'}
134
-
135
-
'@braintree/sanitize-url@6.0.4':
136
-
resolution: {integrity: sha512-s3jaWicZd0pkP0jf5ysyHUI/RE7MHos6qlToFcGWXVp+ykHOy77OUMrfbgJ9it2C5bow7OIQwYYaHjk9XlBQ2A==}
137
-
138
-
'@braintree/sanitize-url@7.1.1':
139
-
resolution: {integrity: sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw==}
140
-
141
-
'@chevrotain/cst-dts-gen@11.0.3':
142
-
resolution: {integrity: sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==}
143
-
144
-
'@chevrotain/gast@11.0.3':
145
-
resolution: {integrity: sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q==}
146
-
147
-
'@chevrotain/regexp-to-ast@11.0.3':
148
-
resolution: {integrity: sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA==}
149
-
150
-
'@chevrotain/types@11.0.3':
151
-
resolution: {integrity: sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ==}
152
-
153
-
'@chevrotain/utils@11.0.3':
154
-
resolution: {integrity: sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ==}
155
122
156
123
'@docsearch/css@3.8.2':
157
124
resolution: {integrity: sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==}
···
314
281
cpu: [x64]
315
282
os: [win32]
316
283
317
-
'@giscus/vue@2.4.0':
318
-
resolution: {integrity: sha512-QOxKHgsMT91myyQagP2v20YYAei1ByZuc3qcaYxbHx4AwOeyVrybDIuRFwG9YDv6OraC86jYnU4Ixd37ddC/0A==}
319
-
peerDependencies:
320
-
vue: '>=3.2.0'
284
+
'@iconify-json/logos@1.2.10':
285
+
resolution: {integrity: sha512-qxaXKJ6fu8jzTMPQdHtNxlfx6tBQ0jXRbHZIYy5Ilh8Lx9US9FsAdzZWUR8MXV8PnWTKGDFO4ZZee9VwerCyMA==}
321
286
322
-
'@iconify-json/logos@1.2.9':
323
-
resolution: {integrity: sha512-G6VCdFnwZcrT6Eveq3m43oJfLw/CX8plwFcE+2jgv3fiGB64pTmnU7Yd1MNZ/eA+/Re2iEDhuCfSNOWTHwwK8w==}
287
+
'@iconify-json/simple-icons@1.2.63':
288
+
resolution: {integrity: sha512-xZl2UWCwE58VlqZ+pDPmaUhE2tq8MVSTJRr4/9nzzHlDdjJ0Ud1VxNXPrwTSgESKY29iCQw3S0r2nJTSNNngHw==}
324
289
325
-
'@iconify-json/simple-icons@1.2.54':
326
-
resolution: {integrity: sha512-OQQYl8yC5j3QklZOYnK31QYe5h47IhyCoxSLd53f0e0nA4dgi8VOZS30SgSAbsecQ+S0xlGJMjXIHTIqZ+ML3w==}
327
-
328
-
'@iconify-json/vscode-icons@1.2.33':
329
-
resolution: {integrity: sha512-2lKDybGxXXeLeeqeNT2YVDYXs5va0YMHf06w3GemS22j/0CCTpKwKDK7REaibsCq3bRV8qX0RJDM4AbREE7L+w==}
290
+
'@iconify-json/vscode-icons@1.2.37':
291
+
resolution: {integrity: sha512-HLRdU6nZks4N8x3JYz6j+b3+hcUCvYvlTLwGzM3xyXfTJyDSA2cAdWcEXfoA4hQMJGA+zCDSPAWFelFptH5Kbw==}
330
292
331
293
'@iconify/types@2.0.0':
332
294
resolution: {integrity: sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==}
333
-
334
-
'@iconify/utils@3.0.2':
335
-
resolution: {integrity: sha512-EfJS0rLfVuRuJRn4psJHtK2A9TqVnkxPpHY6lYHiB9+8eSuudsxbwMiavocG45ujOo6FJ+CIRlRnlOGinzkaGQ==}
336
295
337
296
'@iconify/utils@3.1.0':
338
297
resolution: {integrity: sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==}
···
340
299
'@jridgewell/sourcemap-codec@1.5.5':
341
300
resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
342
301
343
-
'@lit-labs/ssr-dom-shim@1.4.0':
344
-
resolution: {integrity: sha512-ficsEARKnmmW5njugNYKipTm4SFnbik7CXtoencDZzmzo/dQ+2Q0bgkzJuoJP20Aj0F+izzJjOqsnkd6F/o1bw==}
345
-
346
-
'@lit/reactive-element@2.1.1':
347
-
resolution: {integrity: sha512-N+dm5PAYdQ8e6UlywyyrgI2t++wFGXfHx+dSJ1oBrg6FAxUj40jId++EaRm80MKX5JnlH1sBsyZ5h0bcZKemCg==}
348
-
349
-
'@mermaid-js/mermaid-mindmap@9.3.0':
350
-
resolution: {integrity: sha512-IhtYSVBBRYviH1Ehu8gk69pMDF8DSRqXBRDMWrEfHoaMruHeaP2DXA3PBnuwsMaCdPQhlUUcy/7DBLAEIXvCAw==}
351
-
352
-
'@mermaid-js/parser@0.6.3':
353
-
resolution: {integrity: sha512-lnjOhe7zyHjc+If7yT4zoedx2vo4sHaTmtkl1+or8BRTnCtDmcTpAjpzDSfCZrshM5bCoz0GyidzadJAH1xobA==}
354
-
355
-
'@rollup/rollup-android-arm-eabi@4.52.4':
356
-
resolution: {integrity: sha512-BTm2qKNnWIQ5auf4deoetINJm2JzvihvGb9R6K/ETwKLql/Bb3Eg2H1FBp1gUb4YGbydMA3jcmQTR73q7J+GAA==}
302
+
'@rollup/rollup-android-arm-eabi@4.53.5':
303
+
resolution: {integrity: sha512-iDGS/h7D8t7tvZ1t6+WPK04KD0MwzLZrG0se1hzBjSi5fyxlsiggoJHwh18PCFNn7tG43OWb6pdZ6Y+rMlmyNQ==}
357
304
cpu: [arm]
358
305
os: [android]
359
306
360
-
'@rollup/rollup-android-arm64@4.52.4':
361
-
resolution: {integrity: sha512-P9LDQiC5vpgGFgz7GSM6dKPCiqR3XYN1WwJKA4/BUVDjHpYsf3iBEmVz62uyq20NGYbiGPR5cNHI7T1HqxNs2w==}
307
+
'@rollup/rollup-android-arm64@4.53.5':
308
+
resolution: {integrity: sha512-wrSAViWvZHBMMlWk6EJhvg8/rjxzyEhEdgfMMjREHEq11EtJ6IP6yfcCH57YAEca2Oe3FNCE9DSTgU70EIGmVw==}
362
309
cpu: [arm64]
363
310
os: [android]
364
311
365
-
'@rollup/rollup-darwin-arm64@4.52.4':
366
-
resolution: {integrity: sha512-QRWSW+bVccAvZF6cbNZBJwAehmvG9NwfWHwMy4GbWi/BQIA/laTIktebT2ipVjNncqE6GLPxOok5hsECgAxGZg==}
312
+
'@rollup/rollup-darwin-arm64@4.53.5':
313
+
resolution: {integrity: sha512-S87zZPBmRO6u1YXQLwpveZm4JfPpAa6oHBX7/ghSiGH3rz/KDgAu1rKdGutV+WUI6tKDMbaBJomhnT30Y2t4VQ==}
367
314
cpu: [arm64]
368
315
os: [darwin]
369
316
370
-
'@rollup/rollup-darwin-x64@4.52.4':
371
-
resolution: {integrity: sha512-hZgP05pResAkRJxL1b+7yxCnXPGsXU0fG9Yfd6dUaoGk+FhdPKCJ5L1Sumyxn8kvw8Qi5PvQ8ulenUbRjzeCTw==}
317
+
'@rollup/rollup-darwin-x64@4.53.5':
318
+
resolution: {integrity: sha512-YTbnsAaHo6VrAczISxgpTva8EkfQus0VPEVJCEaboHtZRIb6h6j0BNxRBOwnDciFTZLDPW5r+ZBmhL/+YpTZgA==}
372
319
cpu: [x64]
373
320
os: [darwin]
374
321
375
-
'@rollup/rollup-freebsd-arm64@4.52.4':
376
-
resolution: {integrity: sha512-xmc30VshuBNUd58Xk4TKAEcRZHaXlV+tCxIXELiE9sQuK3kG8ZFgSPi57UBJt8/ogfhAF5Oz4ZSUBN77weM+mQ==}
322
+
'@rollup/rollup-freebsd-arm64@4.53.5':
323
+
resolution: {integrity: sha512-1T8eY2J8rKJWzaznV7zedfdhD1BqVs1iqILhmHDq/bqCUZsrMt+j8VCTHhP0vdfbHK3e1IQ7VYx3jlKqwlf+vw==}
377
324
cpu: [arm64]
378
325
os: [freebsd]
379
326
380
-
'@rollup/rollup-freebsd-x64@4.52.4':
381
-
resolution: {integrity: sha512-WdSLpZFjOEqNZGmHflxyifolwAiZmDQzuOzIq9L27ButpCVpD7KzTRtEG1I0wMPFyiyUdOO+4t8GvrnBLQSwpw==}
327
+
'@rollup/rollup-freebsd-x64@4.53.5':
328
+
resolution: {integrity: sha512-sHTiuXyBJApxRn+VFMaw1U+Qsz4kcNlxQ742snICYPrY+DDL8/ZbaC4DVIB7vgZmp3jiDaKA0WpBdP0aqPJoBQ==}
382
329
cpu: [x64]
383
330
os: [freebsd]
384
331
385
-
'@rollup/rollup-linux-arm-gnueabihf@4.52.4':
386
-
resolution: {integrity: sha512-xRiOu9Of1FZ4SxVbB0iEDXc4ddIcjCv2aj03dmW8UrZIW7aIQ9jVJdLBIhxBI+MaTnGAKyvMwPwQnoOEvP7FgQ==}
332
+
'@rollup/rollup-linux-arm-gnueabihf@4.53.5':
333
+
resolution: {integrity: sha512-dV3T9MyAf0w8zPVLVBptVlzaXxka6xg1f16VAQmjg+4KMSTWDvhimI/Y6mp8oHwNrmnmVl9XxJ/w/mO4uIQONA==}
387
334
cpu: [arm]
388
335
os: [linux]
389
336
390
-
'@rollup/rollup-linux-arm-musleabihf@4.52.4':
391
-
resolution: {integrity: sha512-FbhM2p9TJAmEIEhIgzR4soUcsW49e9veAQCziwbR+XWB2zqJ12b4i/+hel9yLiD8pLncDH4fKIPIbt5238341Q==}
337
+
'@rollup/rollup-linux-arm-musleabihf@4.53.5':
338
+
resolution: {integrity: sha512-wIGYC1x/hyjP+KAu9+ewDI+fi5XSNiUi9Bvg6KGAh2TsNMA3tSEs+Sh6jJ/r4BV/bx/CyWu2ue9kDnIdRyafcQ==}
392
339
cpu: [arm]
393
340
os: [linux]
394
341
395
-
'@rollup/rollup-linux-arm64-gnu@4.52.4':
396
-
resolution: {integrity: sha512-4n4gVwhPHR9q/g8lKCyz0yuaD0MvDf7dV4f9tHt0C73Mp8h38UCtSCSE6R9iBlTbXlmA8CjpsZoujhszefqueg==}
342
+
'@rollup/rollup-linux-arm64-gnu@4.53.5':
343
+
resolution: {integrity: sha512-Y+qVA0D9d0y2FRNiG9oM3Hut/DgODZbU9I8pLLPwAsU0tUKZ49cyV1tzmB/qRbSzGvY8lpgGkJuMyuhH7Ma+Vg==}
397
344
cpu: [arm64]
398
345
os: [linux]
399
346
400
-
'@rollup/rollup-linux-arm64-musl@4.52.4':
401
-
resolution: {integrity: sha512-u0n17nGA0nvi/11gcZKsjkLj1QIpAuPFQbR48Subo7SmZJnGxDpspyw2kbpuoQnyK+9pwf3pAoEXerJs/8Mi9g==}
347
+
'@rollup/rollup-linux-arm64-musl@4.53.5':
348
+
resolution: {integrity: sha512-juaC4bEgJsyFVfqhtGLz8mbopaWD+WeSOYr5E16y+1of6KQjc0BpwZLuxkClqY1i8sco+MdyoXPNiCkQou09+g==}
402
349
cpu: [arm64]
403
350
os: [linux]
404
351
405
-
'@rollup/rollup-linux-loong64-gnu@4.52.4':
406
-
resolution: {integrity: sha512-0G2c2lpYtbTuXo8KEJkDkClE/+/2AFPdPAbmaHoE870foRFs4pBrDehilMcrSScrN/fB/1HTaWO4bqw+ewBzMQ==}
352
+
'@rollup/rollup-linux-loong64-gnu@4.53.5':
353
+
resolution: {integrity: sha512-rIEC0hZ17A42iXtHX+EPJVL/CakHo+tT7W0pbzdAGuWOt2jxDFh7A/lRhsNHBcqL4T36+UiAgwO8pbmn3dE8wA==}
407
354
cpu: [loong64]
408
355
os: [linux]
409
356
410
-
'@rollup/rollup-linux-ppc64-gnu@4.52.4':
411
-
resolution: {integrity: sha512-teSACug1GyZHmPDv14VNbvZFX779UqWTsd7KtTM9JIZRDI5NUwYSIS30kzI8m06gOPB//jtpqlhmraQ68b5X2g==}
357
+
'@rollup/rollup-linux-ppc64-gnu@4.53.5':
358
+
resolution: {integrity: sha512-T7l409NhUE552RcAOcmJHj3xyZ2h7vMWzcwQI0hvn5tqHh3oSoclf9WgTl+0QqffWFG8MEVZZP1/OBglKZx52Q==}
412
359
cpu: [ppc64]
413
360
os: [linux]
414
361
415
-
'@rollup/rollup-linux-riscv64-gnu@4.52.4':
416
-
resolution: {integrity: sha512-/MOEW3aHjjs1p4Pw1Xk4+3egRevx8Ji9N6HUIA1Ifh8Q+cg9dremvFCUbOX2Zebz80BwJIgCBUemjqhU5XI5Eg==}
362
+
'@rollup/rollup-linux-riscv64-gnu@4.53.5':
363
+
resolution: {integrity: sha512-7OK5/GhxbnrMcxIFoYfhV/TkknarkYC1hqUw1wU2xUN3TVRLNT5FmBv4KkheSG2xZ6IEbRAhTooTV2+R5Tk0lQ==}
417
364
cpu: [riscv64]
418
365
os: [linux]
419
366
420
-
'@rollup/rollup-linux-riscv64-musl@4.52.4':
421
-
resolution: {integrity: sha512-1HHmsRyh845QDpEWzOFtMCph5Ts+9+yllCrREuBR/vg2RogAQGGBRC8lDPrPOMnrdOJ+mt1WLMOC2Kao/UwcvA==}
367
+
'@rollup/rollup-linux-riscv64-musl@4.53.5':
368
+
resolution: {integrity: sha512-GwuDBE/PsXaTa76lO5eLJTyr2k8QkPipAyOrs4V/KJufHCZBJ495VCGJol35grx9xryk4V+2zd3Ri+3v7NPh+w==}
422
369
cpu: [riscv64]
423
370
os: [linux]
424
371
425
-
'@rollup/rollup-linux-s390x-gnu@4.52.4':
426
-
resolution: {integrity: sha512-seoeZp4L/6D1MUyjWkOMRU6/iLmCU2EjbMTyAG4oIOs1/I82Y5lTeaxW0KBfkUdHAWN7j25bpkt0rjnOgAcQcA==}
372
+
'@rollup/rollup-linux-s390x-gnu@4.53.5':
373
+
resolution: {integrity: sha512-IAE1Ziyr1qNfnmiQLHBURAD+eh/zH1pIeJjeShleII7Vj8kyEm2PF77o+lf3WTHDpNJcu4IXJxNO0Zluro8bOw==}
427
374
cpu: [s390x]
428
375
os: [linux]
429
376
430
-
'@rollup/rollup-linux-x64-gnu@4.52.4':
431
-
resolution: {integrity: sha512-Wi6AXf0k0L7E2gteNsNHUs7UMwCIhsCTs6+tqQ5GPwVRWMaflqGec4Sd8n6+FNFDw9vGcReqk2KzBDhCa1DLYg==}
377
+
'@rollup/rollup-linux-x64-gnu@4.53.5':
378
+
resolution: {integrity: sha512-Pg6E+oP7GvZ4XwgRJBuSXZjcqpIW3yCBhK4BcsANvb47qMvAbCjR6E+1a/U2WXz1JJxp9/4Dno3/iSJLcm5auw==}
432
379
cpu: [x64]
433
380
os: [linux]
434
381
435
-
'@rollup/rollup-linux-x64-musl@4.52.4':
436
-
resolution: {integrity: sha512-dtBZYjDmCQ9hW+WgEkaffvRRCKm767wWhxsFW3Lw86VXz/uJRuD438/XvbZT//B96Vs8oTA8Q4A0AfHbrxP9zw==}
382
+
'@rollup/rollup-linux-x64-musl@4.53.5':
383
+
resolution: {integrity: sha512-txGtluxDKTxaMDzUduGP0wdfng24y1rygUMnmlUJ88fzCCULCLn7oE5kb2+tRB+MWq1QDZT6ObT5RrR8HFRKqg==}
437
384
cpu: [x64]
438
385
os: [linux]
439
386
440
-
'@rollup/rollup-openharmony-arm64@4.52.4':
441
-
resolution: {integrity: sha512-1ox+GqgRWqaB1RnyZXL8PD6E5f7YyRUJYnCqKpNzxzP0TkaUh112NDrR9Tt+C8rJ4x5G9Mk8PQR3o7Ku2RKqKA==}
387
+
'@rollup/rollup-openharmony-arm64@4.53.5':
388
+
resolution: {integrity: sha512-3DFiLPnTxiOQV993fMc+KO8zXHTcIjgaInrqlG8zDp1TlhYl6WgrOHuJkJQ6M8zHEcntSJsUp1XFZSY8C1DYbg==}
442
389
cpu: [arm64]
443
390
os: [openharmony]
444
391
445
-
'@rollup/rollup-win32-arm64-msvc@4.52.4':
446
-
resolution: {integrity: sha512-8GKr640PdFNXwzIE0IrkMWUNUomILLkfeHjXBi/nUvFlpZP+FA8BKGKpacjW6OUUHaNI6sUURxR2U2g78FOHWQ==}
392
+
'@rollup/rollup-win32-arm64-msvc@4.53.5':
393
+
resolution: {integrity: sha512-nggc/wPpNTgjGg75hu+Q/3i32R00Lq1B6N1DO7MCU340MRKL3WZJMjA9U4K4gzy3dkZPXm9E1Nc81FItBVGRlA==}
447
394
cpu: [arm64]
448
395
os: [win32]
449
396
450
-
'@rollup/rollup-win32-ia32-msvc@4.52.4':
451
-
resolution: {integrity: sha512-AIy/jdJ7WtJ/F6EcfOb2GjR9UweO0n43jNObQMb6oGxkYTfLcnN7vYYpG+CN3lLxrQkzWnMOoNSHTW54pgbVxw==}
397
+
'@rollup/rollup-win32-ia32-msvc@4.53.5':
398
+
resolution: {integrity: sha512-U/54pTbdQpPLBdEzCT6NBCFAfSZMvmjr0twhnD9f4EIvlm9wy3jjQ38yQj1AGznrNO65EWQMgm/QUjuIVrYF9w==}
452
399
cpu: [ia32]
453
400
os: [win32]
454
401
455
-
'@rollup/rollup-win32-x64-gnu@4.52.4':
456
-
resolution: {integrity: sha512-UF9KfsH9yEam0UjTwAgdK0anlQ7c8/pWPU2yVjyWcF1I1thABt6WXE47cI71pGiZ8wGvxohBoLnxM04L/wj8mQ==}
402
+
'@rollup/rollup-win32-x64-gnu@4.53.5':
403
+
resolution: {integrity: sha512-2NqKgZSuLH9SXBBV2dWNRCZmocgSOx8OJSdpRaEcRlIfX8YrKxUT6z0F1NpvDVhOsl190UFTRh2F2WDWWCYp3A==}
457
404
cpu: [x64]
458
405
os: [win32]
459
406
460
-
'@rollup/rollup-win32-x64-msvc@4.52.4':
461
-
resolution: {integrity: sha512-bf9PtUa0u8IXDVxzRToFQKsNCRz9qLYfR/MpECxl4mRoWYjAeFjgxj1XdZr2M/GNVpT05p+LgQOHopYDlUu6/w==}
407
+
'@rollup/rollup-win32-x64-msvc@4.53.5':
408
+
resolution: {integrity: sha512-JRpZUhCfhZ4keB5v0fe02gQJy05GqboPOaxvjugW04RLSYYoB/9t2lx2u/tMs/Na/1NXfY8QYjgRljRpN+MjTQ==}
462
409
cpu: [x64]
463
410
os: [win32]
464
411
···
486
433
'@shikijs/vscode-textmate@10.0.2':
487
434
resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
488
435
489
-
'@types/d3-array@3.2.2':
490
-
resolution: {integrity: sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==}
491
-
492
-
'@types/d3-axis@3.0.6':
493
-
resolution: {integrity: sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==}
494
-
495
-
'@types/d3-brush@3.0.6':
496
-
resolution: {integrity: sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==}
497
-
498
-
'@types/d3-chord@3.0.6':
499
-
resolution: {integrity: sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==}
500
-
501
-
'@types/d3-color@3.1.3':
502
-
resolution: {integrity: sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==}
503
-
504
-
'@types/d3-contour@3.0.6':
505
-
resolution: {integrity: sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==}
506
-
507
-
'@types/d3-delaunay@6.0.4':
508
-
resolution: {integrity: sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==}
509
-
510
-
'@types/d3-dispatch@3.0.7':
511
-
resolution: {integrity: sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==}
512
-
513
-
'@types/d3-drag@3.0.7':
514
-
resolution: {integrity: sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==}
515
-
516
-
'@types/d3-dsv@3.0.7':
517
-
resolution: {integrity: sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==}
518
-
519
-
'@types/d3-ease@3.0.2':
520
-
resolution: {integrity: sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==}
521
-
522
-
'@types/d3-fetch@3.0.7':
523
-
resolution: {integrity: sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==}
524
-
525
-
'@types/d3-force@3.0.10':
526
-
resolution: {integrity: sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==}
527
-
528
-
'@types/d3-format@3.0.4':
529
-
resolution: {integrity: sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==}
530
-
531
-
'@types/d3-geo@3.1.0':
532
-
resolution: {integrity: sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==}
533
-
534
-
'@types/d3-hierarchy@3.1.7':
535
-
resolution: {integrity: sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==}
536
-
537
-
'@types/d3-interpolate@3.0.4':
538
-
resolution: {integrity: sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==}
539
-
540
-
'@types/d3-path@3.1.1':
541
-
resolution: {integrity: sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==}
542
-
543
-
'@types/d3-polygon@3.0.2':
544
-
resolution: {integrity: sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==}
545
-
546
-
'@types/d3-quadtree@3.0.6':
547
-
resolution: {integrity: sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==}
548
-
549
-
'@types/d3-random@3.0.3':
550
-
resolution: {integrity: sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==}
551
-
552
-
'@types/d3-scale-chromatic@3.1.0':
553
-
resolution: {integrity: sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==}
554
-
555
-
'@types/d3-scale@4.0.9':
556
-
resolution: {integrity: sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==}
557
-
558
-
'@types/d3-selection@3.0.11':
559
-
resolution: {integrity: sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==}
560
-
561
-
'@types/d3-shape@3.1.7':
562
-
resolution: {integrity: sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==}
563
-
564
-
'@types/d3-time-format@4.0.3':
565
-
resolution: {integrity: sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==}
566
-
567
-
'@types/d3-time@3.0.4':
568
-
resolution: {integrity: sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==}
569
-
570
-
'@types/d3-timer@3.0.2':
571
-
resolution: {integrity: sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==}
572
-
573
-
'@types/d3-transition@3.0.9':
574
-
resolution: {integrity: sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==}
575
-
576
-
'@types/d3-zoom@3.0.8':
577
-
resolution: {integrity: sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==}
578
-
579
-
'@types/d3@7.4.3':
580
-
resolution: {integrity: sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==}
581
-
582
436
'@types/estree@1.0.8':
583
437
resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
584
438
585
-
'@types/geojson@7946.0.16':
586
-
resolution: {integrity: sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==}
587
-
588
439
'@types/hast@3.0.4':
589
440
resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
590
441
···
600
451
'@types/mdurl@2.0.0':
601
452
resolution: {integrity: sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==}
602
453
603
-
'@types/trusted-types@2.0.7':
604
-
resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
605
-
606
454
'@types/unist@3.0.3':
607
455
resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
608
456
···
619
467
vite: ^5.0.0 || ^6.0.0
620
468
vue: ^3.2.25
621
469
622
-
'@vue/compiler-core@3.5.25':
623
-
resolution: {integrity: sha512-vay5/oQJdsNHmliWoZfHPoVZZRmnSWhug0BYT34njkYTPqClh3DNWLkZNJBVSjsNMrg0CCrBfoKkjZQPM/QVUw==}
470
+
'@vue/compiler-core@3.5.26':
471
+
resolution: {integrity: sha512-vXyI5GMfuoBCnv5ucIT7jhHKl55Y477yxP6fc4eUswjP8FG3FFVFd41eNDArR+Uk3QKn2Z85NavjaxLxOC19/w==}
624
472
625
-
'@vue/compiler-dom@3.5.25':
626
-
resolution: {integrity: sha512-4We0OAcMZsKgYoGlMjzYvaoErltdFI2/25wqanuTu+S4gismOTRTBPi4IASOjxWdzIwrYSjnqONfKvuqkXzE2Q==}
473
+
'@vue/compiler-dom@3.5.26':
474
+
resolution: {integrity: sha512-y1Tcd3eXs834QjswshSilCBnKGeQjQXB6PqFn/1nxcQw4pmG42G8lwz+FZPAZAby6gZeHSt/8LMPfZ4Rb+Bd/A==}
627
475
628
-
'@vue/compiler-sfc@3.5.25':
629
-
resolution: {integrity: sha512-PUgKp2rn8fFsI++lF2sO7gwO2d9Yj57Utr5yEsDf3GNaQcowCLKL7sf+LvVFvtJDXUp/03+dC6f2+LCv5aK1ag==}
476
+
'@vue/compiler-sfc@3.5.26':
477
+
resolution: {integrity: sha512-egp69qDTSEZcf4bGOSsprUr4xI73wfrY5oRs6GSgXFTiHrWj4Y3X5Ydtip9QMqiCMCPVwLglB9GBxXtTadJ3mA==}
630
478
631
-
'@vue/compiler-ssr@3.5.25':
632
-
resolution: {integrity: sha512-ritPSKLBcParnsKYi+GNtbdbrIE1mtuFEJ4U1sWeuOMlIziK5GtOL85t5RhsNy4uWIXPgk+OUdpnXiTdzn8o3A==}
479
+
'@vue/compiler-ssr@3.5.26':
480
+
resolution: {integrity: sha512-lZT9/Y0nSIRUPVvapFJEVDbEXruZh2IYHMk2zTtEgJSlP5gVOqeWXH54xDKAaFS4rTnDeDBQUYDtxKyoW9FwDw==}
633
481
634
-
'@vue/devtools-api@7.7.7':
635
-
resolution: {integrity: sha512-lwOnNBH2e7x1fIIbVT7yF5D+YWhqELm55/4ZKf45R9T8r9dE2AIOy8HKjfqzGsoTHFbWbr337O4E0A0QADnjBg==}
482
+
'@vue/devtools-api@7.7.9':
483
+
resolution: {integrity: sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==}
636
484
637
-
'@vue/devtools-kit@7.7.7':
638
-
resolution: {integrity: sha512-wgoZtxcTta65cnZ1Q6MbAfePVFxfM+gq0saaeytoph7nEa7yMXoi6sCPy4ufO111B9msnw0VOWjPEFCXuAKRHA==}
485
+
'@vue/devtools-kit@7.7.9':
486
+
resolution: {integrity: sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==}
639
487
640
-
'@vue/devtools-shared@7.7.7':
641
-
resolution: {integrity: sha512-+udSj47aRl5aKb0memBvcUG9koarqnxNM5yjuREvqwK6T3ap4mn3Zqqc17QrBFTqSMjr3HK1cvStEZpMDpfdyw==}
488
+
'@vue/devtools-shared@7.7.9':
489
+
resolution: {integrity: sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==}
642
490
643
-
'@vue/reactivity@3.5.25':
644
-
resolution: {integrity: sha512-5xfAypCQepv4Jog1U4zn8cZIcbKKFka3AgWHEFQeK65OW+Ys4XybP6z2kKgws4YB43KGpqp5D/K3go2UPPunLA==}
491
+
'@vue/reactivity@3.5.26':
492
+
resolution: {integrity: sha512-9EnYB1/DIiUYYnzlnUBgwU32NNvLp/nhxLXeWRhHUEeWNTn1ECxX8aGO7RTXeX6PPcxe3LLuNBFoJbV4QZ+CFQ==}
645
493
646
-
'@vue/runtime-core@3.5.25':
647
-
resolution: {integrity: sha512-Z751v203YWwYzy460bzsYQISDfPjHTl+6Zzwo/a3CsAf+0ccEjQ8c+0CdX1WsumRTHeywvyUFtW6KvNukT/smA==}
494
+
'@vue/runtime-core@3.5.26':
495
+
resolution: {integrity: sha512-xJWM9KH1kd201w5DvMDOwDHYhrdPTrAatn56oB/LRG4plEQeZRQLw0Bpwih9KYoqmzaxF0OKSn6swzYi84e1/Q==}
648
496
649
-
'@vue/runtime-dom@3.5.25':
650
-
resolution: {integrity: sha512-a4WrkYFbb19i9pjkz38zJBg8wa/rboNERq3+hRRb0dHiJh13c+6kAbgqCPfMaJ2gg4weWD3APZswASOfmKwamA==}
497
+
'@vue/runtime-dom@3.5.26':
498
+
resolution: {integrity: sha512-XLLd/+4sPC2ZkN/6+V4O4gjJu6kSDbHAChvsyWgm1oGbdSO3efvGYnm25yCjtFm/K7rrSDvSfPDgN1pHgS4VNQ==}
651
499
652
-
'@vue/server-renderer@3.5.25':
653
-
resolution: {integrity: sha512-UJaXR54vMG61i8XNIzTSf2Q7MOqZHpp8+x3XLGtE3+fL+nQd+k7O5+X3D/uWrnQXOdMw5VPih+Uremcw+u1woQ==}
500
+
'@vue/server-renderer@3.5.26':
501
+
resolution: {integrity: sha512-TYKLXmrwWKSodyVuO1WAubucd+1XlLg4set0YoV+Hu8Lo79mp/YMwWV5mC5FgtsDxX3qo1ONrxFaTP1OQgy1uA==}
654
502
peerDependencies:
655
-
vue: 3.5.25
656
-
657
-
'@vue/shared@3.5.22':
658
-
resolution: {integrity: sha512-F4yc6palwq3TT0u+FYf0Ns4Tfl9GRFURDN2gWG7L1ecIaS/4fCIuFOjMTnCyjsu/OK6vaDKLCrGAa+KvvH+h4w==}
503
+
vue: 3.5.26
659
504
660
505
'@vue/shared@3.5.25':
661
506
resolution: {integrity: sha512-AbOPdQQnAnzs58H2FrrDxYj/TJfmeS2jdfEEhgiKINy+bnOANmVizIEgq1r+C5zsbs6l1CCQxtcj71rwNQ4jWg==}
662
507
508
+
'@vue/shared@3.5.26':
509
+
resolution: {integrity: sha512-7Z6/y3uFI5PRoKeorTOSXKcDj0MSasfNNltcslbFrPpcw6aXRUALq4IfJlaTRspiWIUOEZbrpM+iQGmCOiWe4A==}
510
+
663
511
'@vueuse/core@12.8.2':
664
512
resolution: {integrity: sha512-HbvCmZdzAu3VGi/pWYm5Ut+Kd9mn1ZHnn4L5G8kOQTPs/IwIAmJoBrmYk2ckLArgMXZj0AW3n5CAejLUO+PhdQ==}
665
513
···
715
563
engines: {node: '>=0.4.0'}
716
564
hasBin: true
717
565
718
-
algoliasearch@5.40.0:
719
-
resolution: {integrity: sha512-a9aIL2E3Z7uYUPMCmjMFFd5MWhn+ccTubEvnMy7rOTZCB62dXBJtz0R5BZ/TPuX3R9ocBsgWuAbGWQ+Ph4Fmlg==}
566
+
algoliasearch@5.46.0:
567
+
resolution: {integrity: sha512-7ML6fa2K93FIfifG3GMWhDEwT5qQzPTmoHKCTvhzGEwdbQ4n0yYUWZlLYT75WllTGJCJtNUI0C1ybN4BCegqvg==}
720
568
engines: {node: '>= 14.0.0'}
721
569
722
-
birpc@2.6.1:
723
-
resolution: {integrity: sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==}
570
+
birpc@2.9.0:
571
+
resolution: {integrity: sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==}
724
572
725
573
ccount@2.0.1:
726
574
resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
···
731
579
character-entities-legacy@3.0.0:
732
580
resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
733
581
734
-
chevrotain-allstar@0.3.1:
735
-
resolution: {integrity: sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==}
736
-
peerDependencies:
737
-
chevrotain: ^11.0.0
738
-
739
-
chevrotain@11.0.3:
740
-
resolution: {integrity: sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==}
741
-
742
582
comma-separated-tokens@2.0.3:
743
583
resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
744
584
745
-
commander@7.2.0:
746
-
resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
747
-
engines: {node: '>= 10'}
748
-
749
-
commander@8.3.0:
750
-
resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
751
-
engines: {node: '>= 12'}
752
-
753
585
confbox@0.1.8:
754
586
resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
755
587
756
-
confbox@0.2.2:
757
-
resolution: {integrity: sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==}
758
-
759
-
copy-anything@3.0.5:
760
-
resolution: {integrity: sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==}
761
-
engines: {node: '>=12.13'}
762
-
763
-
cose-base@1.0.3:
764
-
resolution: {integrity: sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==}
765
-
766
-
cose-base@2.2.0:
767
-
resolution: {integrity: sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==}
588
+
copy-anything@4.0.5:
589
+
resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
590
+
engines: {node: '>=18'}
768
591
769
592
csstype@3.2.3:
770
593
resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
771
594
772
-
cytoscape-cose-bilkent@4.1.0:
773
-
resolution: {integrity: sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==}
774
-
peerDependencies:
775
-
cytoscape: ^3.2.0
776
-
777
-
cytoscape-fcose@2.2.0:
778
-
resolution: {integrity: sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==}
779
-
peerDependencies:
780
-
cytoscape: ^3.2.0
781
-
782
-
cytoscape@3.33.1:
783
-
resolution: {integrity: sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==}
784
-
engines: {node: '>=0.10'}
785
-
786
-
d3-array@2.12.1:
787
-
resolution: {integrity: sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==}
788
-
789
-
d3-array@3.2.4:
790
-
resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==}
791
-
engines: {node: '>=12'}
792
-
793
-
d3-axis@3.0.0:
794
-
resolution: {integrity: sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==}
795
-
engines: {node: '>=12'}
796
-
797
-
d3-brush@3.0.0:
798
-
resolution: {integrity: sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==}
799
-
engines: {node: '>=12'}
800
-
801
-
d3-chord@3.0.1:
802
-
resolution: {integrity: sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==}
803
-
engines: {node: '>=12'}
804
-
805
-
d3-color@3.1.0:
806
-
resolution: {integrity: sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==}
807
-
engines: {node: '>=12'}
808
-
809
-
d3-contour@4.0.2:
810
-
resolution: {integrity: sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==}
811
-
engines: {node: '>=12'}
812
-
813
-
d3-delaunay@6.0.4:
814
-
resolution: {integrity: sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==}
815
-
engines: {node: '>=12'}
816
-
817
-
d3-dispatch@3.0.1:
818
-
resolution: {integrity: sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==}
819
-
engines: {node: '>=12'}
820
-
821
-
d3-drag@3.0.0:
822
-
resolution: {integrity: sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==}
823
-
engines: {node: '>=12'}
824
-
825
-
d3-dsv@3.0.1:
826
-
resolution: {integrity: sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==}
827
-
engines: {node: '>=12'}
828
-
hasBin: true
829
-
830
-
d3-ease@3.0.1:
831
-
resolution: {integrity: sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==}
832
-
engines: {node: '>=12'}
833
-
834
-
d3-fetch@3.0.1:
835
-
resolution: {integrity: sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==}
836
-
engines: {node: '>=12'}
837
-
838
-
d3-force@3.0.0:
839
-
resolution: {integrity: sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==}
840
-
engines: {node: '>=12'}
841
-
842
-
d3-format@3.1.0:
843
-
resolution: {integrity: sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==}
844
-
engines: {node: '>=12'}
845
-
846
-
d3-geo@3.1.1:
847
-
resolution: {integrity: sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==}
848
-
engines: {node: '>=12'}
849
-
850
-
d3-hierarchy@3.1.2:
851
-
resolution: {integrity: sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==}
852
-
engines: {node: '>=12'}
853
-
854
-
d3-interpolate@3.0.1:
855
-
resolution: {integrity: sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==}
856
-
engines: {node: '>=12'}
857
-
858
-
d3-path@1.0.9:
859
-
resolution: {integrity: sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==}
860
-
861
-
d3-path@3.1.0:
862
-
resolution: {integrity: sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==}
863
-
engines: {node: '>=12'}
864
-
865
-
d3-polygon@3.0.1:
866
-
resolution: {integrity: sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==}
867
-
engines: {node: '>=12'}
868
-
869
-
d3-quadtree@3.0.1:
870
-
resolution: {integrity: sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==}
871
-
engines: {node: '>=12'}
872
-
873
-
d3-random@3.0.1:
874
-
resolution: {integrity: sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==}
875
-
engines: {node: '>=12'}
876
-
877
-
d3-sankey@0.12.3:
878
-
resolution: {integrity: sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==}
879
-
880
-
d3-scale-chromatic@3.1.0:
881
-
resolution: {integrity: sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==}
882
-
engines: {node: '>=12'}
883
-
884
-
d3-scale@4.0.2:
885
-
resolution: {integrity: sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==}
886
-
engines: {node: '>=12'}
887
-
888
-
d3-selection@3.0.0:
889
-
resolution: {integrity: sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==}
890
-
engines: {node: '>=12'}
891
-
892
-
d3-shape@1.3.7:
893
-
resolution: {integrity: sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==}
894
-
895
-
d3-shape@3.2.0:
896
-
resolution: {integrity: sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==}
897
-
engines: {node: '>=12'}
898
-
899
-
d3-time-format@4.1.0:
900
-
resolution: {integrity: sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==}
901
-
engines: {node: '>=12'}
902
-
903
-
d3-time@3.1.0:
904
-
resolution: {integrity: sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==}
905
-
engines: {node: '>=12'}
906
-
907
-
d3-timer@3.0.1:
908
-
resolution: {integrity: sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==}
909
-
engines: {node: '>=12'}
910
-
911
-
d3-transition@3.0.1:
912
-
resolution: {integrity: sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==}
913
-
engines: {node: '>=12'}
914
-
peerDependencies:
915
-
d3-selection: 2 - 3
916
-
917
-
d3-zoom@3.0.0:
918
-
resolution: {integrity: sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==}
919
-
engines: {node: '>=12'}
920
-
921
-
d3@7.9.0:
922
-
resolution: {integrity: sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==}
923
-
engines: {node: '>=12'}
924
-
925
-
dagre-d3-es@7.0.13:
926
-
resolution: {integrity: sha512-efEhnxpSuwpYOKRm/L5KbqoZmNNukHa/Flty4Wp62JRvgH2ojwVgPgdYyr4twpieZnyRDdIH7PY2mopX26+j2Q==}
927
-
928
-
dayjs@1.11.19:
929
-
resolution: {integrity: sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==}
930
-
931
-
debug@4.4.3:
932
-
resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
933
-
engines: {node: '>=6.0'}
934
-
peerDependencies:
935
-
supports-color: '*'
936
-
peerDependenciesMeta:
937
-
supports-color:
938
-
optional: true
939
-
940
-
delaunator@5.0.1:
941
-
resolution: {integrity: sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw==}
942
-
943
595
dequal@2.0.3:
944
596
resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
945
597
engines: {node: '>=6'}
946
598
947
599
devlop@1.1.0:
948
600
resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
949
-
950
-
dompurify@3.3.0:
951
-
resolution: {integrity: sha512-r+f6MYR1gGN1eJv0TVQbhA7if/U7P87cdPl3HN5rikqaBSBxLiCb/b9O+2eG0cxz0ghyU+mU1QkbsOwERMYlWQ==}
952
601
953
602
emoji-regex-xs@1.0.0:
954
603
resolution: {integrity: sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==}
955
604
956
-
entities@4.5.0:
957
-
resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
605
+
entities@7.0.0:
606
+
resolution: {integrity: sha512-FDWG5cmEYf2Z00IkYRhbFrwIwvdFKH07uV8dvNy0omp/Qb1xcyCWp2UDtcwJF4QZZvk0sLudP6/hAu42TaqVhQ==}
958
607
engines: {node: '>=0.12'}
959
608
960
609
esbuild@0.21.5:
···
965
614
estree-walker@2.0.2:
966
615
resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
967
616
968
-
exsolve@1.0.7:
969
-
resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==}
970
-
971
-
focus-trap@7.6.5:
972
-
resolution: {integrity: sha512-7Ke1jyybbbPZyZXFxEftUtxFGLMpE2n6A+z//m4CRDlj0hW+o3iYSmh8nFlYMurOiJVDmJRilUQtJr08KfIxlg==}
617
+
focus-trap@7.6.6:
618
+
resolution: {integrity: sha512-v/Z8bvMCajtx4mEXmOo7QEsIzlIOqRXTIwgUfsFOF9gEsespdbD0AkPIka1bSXZ8Y8oZ+2IVDQZePkTfEHZl7Q==}
973
619
974
620
fsevents@2.3.3:
975
621
resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
976
622
engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
977
623
os: [darwin]
978
624
979
-
giscus@1.6.0:
980
-
resolution: {integrity: sha512-Zrsi8r4t1LVW950keaWcsURuZUQwUaMKjvJgTCY125vkW6OiEBkatE7ScJDbpqKHdZwb///7FVC21SE3iFK3PQ==}
981
-
982
-
globals@15.15.0:
983
-
resolution: {integrity: sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==}
984
-
engines: {node: '>=18'}
985
-
986
-
hachure-fill@0.5.2:
987
-
resolution: {integrity: sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg==}
988
-
989
625
hast-util-to-html@9.0.5:
990
626
resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
991
627
···
998
634
html-void-elements@3.0.0:
999
635
resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
1000
636
1001
-
iconv-lite@0.6.3:
1002
-
resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
1003
-
engines: {node: '>=0.10.0'}
1004
-
1005
-
internmap@1.0.1:
1006
-
resolution: {integrity: sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==}
1007
-
1008
-
internmap@2.0.3:
1009
-
resolution: {integrity: sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==}
1010
-
engines: {node: '>=12'}
1011
-
1012
-
is-what@4.1.16:
1013
-
resolution: {integrity: sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==}
1014
-
engines: {node: '>=12.13'}
1015
-
1016
-
katex@0.16.25:
1017
-
resolution: {integrity: sha512-woHRUZ/iF23GBP1dkDQMh1QBad9dmr8/PAwNA54VrSOVYgI12MAcE14TqnDdQOdzyEonGzMepYnqBMYdsoAr8Q==}
1018
-
hasBin: true
1019
-
1020
-
khroma@2.1.0:
1021
-
resolution: {integrity: sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==}
1022
-
1023
-
kolorist@1.8.0:
1024
-
resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==}
1025
-
1026
-
langium@3.3.1:
1027
-
resolution: {integrity: sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w==}
1028
-
engines: {node: '>=16.0.0'}
1029
-
1030
-
layout-base@1.0.2:
1031
-
resolution: {integrity: sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==}
1032
-
1033
-
layout-base@2.0.1:
1034
-
resolution: {integrity: sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==}
1035
-
1036
-
lit-element@4.2.1:
1037
-
resolution: {integrity: sha512-WGAWRGzirAgyphK2urmYOV72tlvnxw7YfyLDgQ+OZnM9vQQBQnumQ7jUJe6unEzwGU3ahFOjuz1iz1jjrpCPuw==}
1038
-
1039
-
lit-html@3.3.1:
1040
-
resolution: {integrity: sha512-S9hbyDu/vs1qNrithiNyeyv64c9yqiW9l+DBgI18fL+MTvOtWoFR0FWiyq1TxaYef5wNlpEmzlXoBlZEO+WjoA==}
1041
-
1042
-
lit@3.3.1:
1043
-
resolution: {integrity: sha512-Ksr/8L3PTapbdXJCk+EJVB78jDodUMaP54gD24W186zGRARvwrsPfS60wae/SSCTCNZVPd1chXqio1qHQmu4NA==}
1044
-
1045
-
local-pkg@1.1.2:
1046
-
resolution: {integrity: sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==}
1047
-
engines: {node: '>=14'}
1048
-
1049
-
lodash-es@4.17.21:
1050
-
resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==}
637
+
is-what@5.5.0:
638
+
resolution: {integrity: sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==}
639
+
engines: {node: '>=18'}
1051
640
1052
641
magic-string@0.30.21:
1053
642
resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
···
1058
647
markdown-it-footnote@4.0.0:
1059
648
resolution: {integrity: sha512-WYJ7urf+khJYl3DqofQpYfEYkZKbmXmwxQV8c8mO/hGIhgZ1wOe7R4HLFNwqx7TjILbnC98fuyeSsin19JdFcQ==}
1060
649
1061
-
marked@16.4.2:
1062
-
resolution: {integrity: sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA==}
1063
-
engines: {node: '>= 20'}
1064
-
hasBin: true
1065
-
1066
-
mdast-util-to-hast@13.2.0:
1067
-
resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==}
1068
-
1069
-
mermaid@11.12.2:
1070
-
resolution: {integrity: sha512-n34QPDPEKmaeCG4WDMGy0OT6PSyxKCfy2pJgShP+Qow2KLrvWjclwbc3yXfSIf4BanqWEhQEpngWwNp/XhZt6w==}
650
+
mdast-util-to-hast@13.2.1:
651
+
resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}
1071
652
1072
653
micromark-util-character@2.1.1:
1073
654
resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
···
1093
674
mlly@1.8.0:
1094
675
resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==}
1095
676
1096
-
ms@2.1.3:
1097
-
resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
1098
-
1099
677
nanoid@3.3.11:
1100
678
resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
1101
679
engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
1102
680
hasBin: true
1103
681
1104
-
non-layered-tidy-tree-layout@2.0.2:
1105
-
resolution: {integrity: sha512-gkXMxRzUH+PB0ax9dUN0yYF0S25BqeAYqhgMaLUFmpXLEk7Fcu8f4emJuOAY0V8kjDICxROIKsTAKsV/v355xw==}
1106
-
1107
682
oniguruma-to-es@3.1.1:
1108
683
resolution: {integrity: sha512-bUH8SDvPkH3ho3dvwJwfonjlQ4R80vjyvrU8YpxuROddv55vAEJrTuCuCVUhhsHbtlD9tGGbaNApGQckXhS8iQ==}
1109
684
1110
685
package-manager-detector@1.6.0:
1111
686
resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==}
1112
687
1113
-
path-data-parser@0.1.0:
1114
-
resolution: {integrity: sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==}
1115
-
1116
688
pathe@2.0.3:
1117
689
resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
1118
690
···
1125
697
pkg-types@1.3.1:
1126
698
resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
1127
699
1128
-
pkg-types@2.3.0:
1129
-
resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==}
1130
-
1131
-
points-on-curve@0.2.0:
1132
-
resolution: {integrity: sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==}
1133
-
1134
-
points-on-path@0.2.1:
1135
-
resolution: {integrity: sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==}
1136
-
1137
700
postcss@8.5.6:
1138
701
resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
1139
702
engines: {node: ^10 || ^12 || >=14}
1140
703
1141
-
preact@10.27.2:
1142
-
resolution: {integrity: sha512-5SYSgFKSyhCbk6SrXyMpqjb5+MQBgfvEKE/OC+PujcY34sOpqtr+0AZQtPYx5IA6VxynQ7rUPCtKzyovpj9Bpg==}
704
+
preact@10.28.0:
705
+
resolution: {integrity: sha512-rytDAoiXr3+t6OIP3WGlDd0ouCUG1iCWzkcY3++Nreuoi17y6T5i/zRhe6uYfoVcxq6YU+sBtJouuRDsq8vvqA==}
1143
706
1144
707
property-information@7.1.0:
1145
708
resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==}
1146
709
1147
-
quansync@0.2.11:
1148
-
resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==}
1149
-
1150
710
regex-recursion@6.0.2:
1151
711
resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==}
1152
712
1153
713
regex-utilities@2.3.0:
1154
714
resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==}
1155
715
1156
-
regex@6.0.1:
1157
-
resolution: {integrity: sha512-uorlqlzAKjKQZ5P+kTJr3eeJGSVroLKoHmquUj4zHWuR+hEyNqlXsSKlYYF5F4NI6nl7tWCs0apKJ0lmfsXAPA==}
716
+
regex@6.1.0:
717
+
resolution: {integrity: sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==}
1158
718
1159
719
rfdc@1.4.1:
1160
720
resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
1161
721
1162
-
robust-predicates@3.0.2:
1163
-
resolution: {integrity: sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==}
1164
-
1165
-
rollup@4.52.4:
1166
-
resolution: {integrity: sha512-CLEVl+MnPAiKh5pl4dEWSyMTpuflgNQiLGhMv8ezD5W/qP8AKvmYpCOKRRNOh7oRKnauBZ4SyeYkMS+1VSyKwQ==}
722
+
rollup@4.53.5:
723
+
resolution: {integrity: sha512-iTNAbFSlRpcHeeWu73ywU/8KuU/LZmNCSxp6fjQkJBD3ivUb8tpDrXhIxEzA05HlYMEwmtaUnb3RP+YNv162OQ==}
1167
724
engines: {node: '>=18.0.0', npm: '>=8.0.0'}
1168
725
hasBin: true
1169
726
1170
-
roughjs@4.6.6:
1171
-
resolution: {integrity: sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==}
1172
-
1173
-
rw@1.3.3:
1174
-
resolution: {integrity: sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==}
1175
-
1176
-
safer-buffer@2.1.2:
1177
-
resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
1178
-
1179
727
search-insights@2.17.3:
1180
728
resolution: {integrity: sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==}
1181
729
···
1196
744
stringify-entities@4.0.4:
1197
745
resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
1198
746
1199
-
stylis@4.3.6:
1200
-
resolution: {integrity: sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==}
1201
-
1202
-
superjson@2.2.2:
1203
-
resolution: {integrity: sha512-5JRxVqC8I8NuOUjzBbvVJAKNM8qoVuH0O77h4WInc/qC2q5IreqKxYwgkga3PfA22OayK2ikceb/B26dztPl+Q==}
747
+
superjson@2.2.6:
748
+
resolution: {integrity: sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==}
1204
749
engines: {node: '>=16'}
1205
750
1206
-
tabbable@6.2.0:
1207
-
resolution: {integrity: sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew==}
751
+
tabbable@6.3.0:
752
+
resolution: {integrity: sha512-EIHvdY5bPLuWForiR/AN2Bxngzpuwn1is4asboytXtpTgsArc+WmSJKVLlhdh71u7jFcryDqB2A8lQvj78MkyQ==}
1208
753
1209
754
tinyexec@1.0.2:
1210
755
resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==}
···
1213
758
trim-lines@3.0.1:
1214
759
resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
1215
760
1216
-
ts-dedent@2.2.0:
1217
-
resolution: {integrity: sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==}
1218
-
engines: {node: '>=6.10'}
1219
-
1220
761
ufo@1.6.1:
1221
762
resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==}
1222
763
1223
-
unist-util-is@6.0.0:
1224
-
resolution: {integrity: sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==}
764
+
unist-util-is@6.0.1:
765
+
resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==}
1225
766
1226
767
unist-util-position@5.0.0:
1227
768
resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
···
1229
770
unist-util-stringify-position@4.0.0:
1230
771
resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
1231
772
1232
-
unist-util-visit-parents@6.0.1:
1233
-
resolution: {integrity: sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==}
773
+
unist-util-visit-parents@6.0.2:
774
+
resolution: {integrity: sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==}
1234
775
1235
776
unist-util-visit@5.0.0:
1236
777
resolution: {integrity: sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==}
1237
778
1238
-
uuid@11.1.0:
1239
-
resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==}
1240
-
hasBin: true
1241
-
1242
779
vfile-message@4.0.3:
1243
780
resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==}
1244
781
1245
782
vfile@6.0.3:
1246
783
resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
1247
784
1248
-
vite@5.4.20:
1249
-
resolution: {integrity: sha512-j3lYzGC3P+B5Yfy/pfKNgVEg4+UtcIJcVRt2cDjIOmhLourAqPqf8P7acgxeiSgUB7E3p2P8/3gNIgDLpwzs4g==}
785
+
vite@5.4.21:
786
+
resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}
1250
787
engines: {node: ^18.0.0 || >=20.0.0}
1251
788
hasBin: true
1252
789
peerDependencies:
···
1276
813
terser:
1277
814
optional: true
1278
815
1279
-
vitepress-plugin-comment-with-giscus@1.1.15:
1280
-
resolution: {integrity: sha512-1DJjgN+7SYvn5ZkjuSXPmz7nlqfcrh4qCGGviiZghA2ELXnaO2m9WY7m+RisPSaqCn90xqe0JbO2T4NMq8iUBg==}
1281
-
1282
816
vitepress-plugin-group-icons@1.6.5:
1283
817
resolution: {integrity: sha512-+pg4+GKDq2fLqKb1Sat5p1p4SuIZ5tEPxu8HjpwoeecZ/VaXKy6Bdf0wyjedjaTAyZQzXbvyavJegqAcQ+B0VA==}
1284
818
peerDependencies:
···
1286
820
peerDependenciesMeta:
1287
821
vite:
1288
822
optional: true
1289
-
1290
-
vitepress-plugin-mermaid@2.0.17:
1291
-
resolution: {integrity: sha512-IUzYpwf61GC6k0XzfmAmNrLvMi9TRrVRMsUyCA8KNXhg/mQ1VqWnO0/tBVPiX5UoKF1mDUwqn5QV4qAJl6JnUg==}
1292
-
peerDependencies:
1293
-
mermaid: 10 || 11
1294
-
vitepress: ^1.0.0 || ^1.0.0-alpha
1295
823
1296
824
vitepress@1.6.4:
1297
825
resolution: {integrity: sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==}
···
1305
833
postcss:
1306
834
optional: true
1307
835
1308
-
vscode-jsonrpc@8.2.0:
1309
-
resolution: {integrity: sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==}
1310
-
engines: {node: '>=14.0.0'}
1311
-
1312
-
vscode-languageserver-protocol@3.17.5:
1313
-
resolution: {integrity: sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==}
1314
-
1315
-
vscode-languageserver-textdocument@1.0.12:
1316
-
resolution: {integrity: sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==}
1317
-
1318
-
vscode-languageserver-types@3.17.5:
1319
-
resolution: {integrity: sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==}
1320
-
1321
-
vscode-languageserver@9.0.1:
1322
-
resolution: {integrity: sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==}
1323
-
hasBin: true
1324
-
1325
-
vscode-uri@3.0.8:
1326
-
resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==}
1327
-
1328
-
vue@3.5.25:
1329
-
resolution: {integrity: sha512-YLVdgv2K13WJ6n+kD5owehKtEXwdwXuj2TTyJMsO7pSeKw2bfRNZGjhB7YzrpbMYj5b5QsUebHpOqR3R3ziy/g==}
836
+
vue@3.5.26:
837
+
resolution: {integrity: sha512-SJ/NTccVyAoNUJmkM9KUqPcYlY+u8OVL1X5EW9RIs3ch5H2uERxyyIUI4MRxVCSOiEcupX9xNGde1tL9ZKpimA==}
1330
838
peerDependencies:
1331
839
typescript: '*'
1332
840
peerDependenciesMeta:
···
1338
846
1339
847
snapshots:
1340
848
1341
-
'@algolia/abtesting@1.6.0':
849
+
'@algolia/abtesting@1.12.0':
1342
850
dependencies:
1343
-
'@algolia/client-common': 5.40.0
1344
-
'@algolia/requester-browser-xhr': 5.40.0
1345
-
'@algolia/requester-fetch': 5.40.0
1346
-
'@algolia/requester-node-http': 5.40.0
851
+
'@algolia/client-common': 5.46.0
852
+
'@algolia/requester-browser-xhr': 5.46.0
853
+
'@algolia/requester-fetch': 5.46.0
854
+
'@algolia/requester-node-http': 5.46.0
1347
855
1348
-
'@algolia/autocomplete-core@1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)(search-insights@2.17.3)':
856
+
'@algolia/autocomplete-core@1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)(search-insights@2.17.3)':
1349
857
dependencies:
1350
-
'@algolia/autocomplete-plugin-algolia-insights': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)(search-insights@2.17.3)
1351
-
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)
858
+
'@algolia/autocomplete-plugin-algolia-insights': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)(search-insights@2.17.3)
859
+
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)
1352
860
transitivePeerDependencies:
1353
861
- '@algolia/client-search'
1354
862
- algoliasearch
1355
863
- search-insights
1356
864
1357
-
'@algolia/autocomplete-plugin-algolia-insights@1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)(search-insights@2.17.3)':
865
+
'@algolia/autocomplete-plugin-algolia-insights@1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)(search-insights@2.17.3)':
1358
866
dependencies:
1359
-
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)
867
+
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)
1360
868
search-insights: 2.17.3
1361
869
transitivePeerDependencies:
1362
870
- '@algolia/client-search'
1363
871
- algoliasearch
1364
872
1365
-
'@algolia/autocomplete-preset-algolia@1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)':
873
+
'@algolia/autocomplete-preset-algolia@1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)':
1366
874
dependencies:
1367
-
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)
1368
-
'@algolia/client-search': 5.40.0
1369
-
algoliasearch: 5.40.0
875
+
'@algolia/autocomplete-shared': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)
876
+
'@algolia/client-search': 5.46.0
877
+
algoliasearch: 5.46.0
1370
878
1371
-
'@algolia/autocomplete-shared@1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)':
879
+
'@algolia/autocomplete-shared@1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)':
1372
880
dependencies:
1373
-
'@algolia/client-search': 5.40.0
1374
-
algoliasearch: 5.40.0
881
+
'@algolia/client-search': 5.46.0
882
+
algoliasearch: 5.46.0
1375
883
1376
-
'@algolia/client-abtesting@5.40.0':
884
+
'@algolia/client-abtesting@5.46.0':
1377
885
dependencies:
1378
-
'@algolia/client-common': 5.40.0
1379
-
'@algolia/requester-browser-xhr': 5.40.0
1380
-
'@algolia/requester-fetch': 5.40.0
1381
-
'@algolia/requester-node-http': 5.40.0
886
+
'@algolia/client-common': 5.46.0
887
+
'@algolia/requester-browser-xhr': 5.46.0
888
+
'@algolia/requester-fetch': 5.46.0
889
+
'@algolia/requester-node-http': 5.46.0
1382
890
1383
-
'@algolia/client-analytics@5.40.0':
891
+
'@algolia/client-analytics@5.46.0':
1384
892
dependencies:
1385
-
'@algolia/client-common': 5.40.0
1386
-
'@algolia/requester-browser-xhr': 5.40.0
1387
-
'@algolia/requester-fetch': 5.40.0
1388
-
'@algolia/requester-node-http': 5.40.0
893
+
'@algolia/client-common': 5.46.0
894
+
'@algolia/requester-browser-xhr': 5.46.0
895
+
'@algolia/requester-fetch': 5.46.0
896
+
'@algolia/requester-node-http': 5.46.0
1389
897
1390
-
'@algolia/client-common@5.40.0': {}
898
+
'@algolia/client-common@5.46.0': {}
1391
899
1392
-
'@algolia/client-insights@5.40.0':
900
+
'@algolia/client-insights@5.46.0':
1393
901
dependencies:
1394
-
'@algolia/client-common': 5.40.0
1395
-
'@algolia/requester-browser-xhr': 5.40.0
1396
-
'@algolia/requester-fetch': 5.40.0
1397
-
'@algolia/requester-node-http': 5.40.0
902
+
'@algolia/client-common': 5.46.0
903
+
'@algolia/requester-browser-xhr': 5.46.0
904
+
'@algolia/requester-fetch': 5.46.0
905
+
'@algolia/requester-node-http': 5.46.0
1398
906
1399
-
'@algolia/client-personalization@5.40.0':
907
+
'@algolia/client-personalization@5.46.0':
1400
908
dependencies:
1401
-
'@algolia/client-common': 5.40.0
1402
-
'@algolia/requester-browser-xhr': 5.40.0
1403
-
'@algolia/requester-fetch': 5.40.0
1404
-
'@algolia/requester-node-http': 5.40.0
909
+
'@algolia/client-common': 5.46.0
910
+
'@algolia/requester-browser-xhr': 5.46.0
911
+
'@algolia/requester-fetch': 5.46.0
912
+
'@algolia/requester-node-http': 5.46.0
1405
913
1406
-
'@algolia/client-query-suggestions@5.40.0':
914
+
'@algolia/client-query-suggestions@5.46.0':
1407
915
dependencies:
1408
-
'@algolia/client-common': 5.40.0
1409
-
'@algolia/requester-browser-xhr': 5.40.0
1410
-
'@algolia/requester-fetch': 5.40.0
1411
-
'@algolia/requester-node-http': 5.40.0
916
+
'@algolia/client-common': 5.46.0
917
+
'@algolia/requester-browser-xhr': 5.46.0
918
+
'@algolia/requester-fetch': 5.46.0
919
+
'@algolia/requester-node-http': 5.46.0
1412
920
1413
-
'@algolia/client-search@5.40.0':
921
+
'@algolia/client-search@5.46.0':
1414
922
dependencies:
1415
-
'@algolia/client-common': 5.40.0
1416
-
'@algolia/requester-browser-xhr': 5.40.0
1417
-
'@algolia/requester-fetch': 5.40.0
1418
-
'@algolia/requester-node-http': 5.40.0
923
+
'@algolia/client-common': 5.46.0
924
+
'@algolia/requester-browser-xhr': 5.46.0
925
+
'@algolia/requester-fetch': 5.46.0
926
+
'@algolia/requester-node-http': 5.46.0
1419
927
1420
-
'@algolia/ingestion@1.40.0':
928
+
'@algolia/ingestion@1.46.0':
1421
929
dependencies:
1422
-
'@algolia/client-common': 5.40.0
1423
-
'@algolia/requester-browser-xhr': 5.40.0
1424
-
'@algolia/requester-fetch': 5.40.0
1425
-
'@algolia/requester-node-http': 5.40.0
930
+
'@algolia/client-common': 5.46.0
931
+
'@algolia/requester-browser-xhr': 5.46.0
932
+
'@algolia/requester-fetch': 5.46.0
933
+
'@algolia/requester-node-http': 5.46.0
1426
934
1427
-
'@algolia/monitoring@1.40.0':
935
+
'@algolia/monitoring@1.46.0':
1428
936
dependencies:
1429
-
'@algolia/client-common': 5.40.0
1430
-
'@algolia/requester-browser-xhr': 5.40.0
1431
-
'@algolia/requester-fetch': 5.40.0
1432
-
'@algolia/requester-node-http': 5.40.0
937
+
'@algolia/client-common': 5.46.0
938
+
'@algolia/requester-browser-xhr': 5.46.0
939
+
'@algolia/requester-fetch': 5.46.0
940
+
'@algolia/requester-node-http': 5.46.0
1433
941
1434
-
'@algolia/recommend@5.40.0':
942
+
'@algolia/recommend@5.46.0':
1435
943
dependencies:
1436
-
'@algolia/client-common': 5.40.0
1437
-
'@algolia/requester-browser-xhr': 5.40.0
1438
-
'@algolia/requester-fetch': 5.40.0
1439
-
'@algolia/requester-node-http': 5.40.0
944
+
'@algolia/client-common': 5.46.0
945
+
'@algolia/requester-browser-xhr': 5.46.0
946
+
'@algolia/requester-fetch': 5.46.0
947
+
'@algolia/requester-node-http': 5.46.0
1440
948
1441
-
'@algolia/requester-browser-xhr@5.40.0':
949
+
'@algolia/requester-browser-xhr@5.46.0':
1442
950
dependencies:
1443
-
'@algolia/client-common': 5.40.0
951
+
'@algolia/client-common': 5.46.0
1444
952
1445
-
'@algolia/requester-fetch@5.40.0':
953
+
'@algolia/requester-fetch@5.46.0':
1446
954
dependencies:
1447
-
'@algolia/client-common': 5.40.0
955
+
'@algolia/client-common': 5.46.0
1448
956
1449
-
'@algolia/requester-node-http@5.40.0':
957
+
'@algolia/requester-node-http@5.46.0':
1450
958
dependencies:
1451
-
'@algolia/client-common': 5.40.0
959
+
'@algolia/client-common': 5.46.0
1452
960
1453
961
'@antfu/install-pkg@1.1.0':
1454
962
dependencies:
1455
963
package-manager-detector: 1.6.0
1456
964
tinyexec: 1.0.2
1457
965
1458
-
'@antfu/utils@9.3.0': {}
1459
-
1460
966
'@babel/helper-string-parser@7.27.1': {}
1461
967
1462
968
'@babel/helper-validator-identifier@7.28.5': {}
···
1470
976
'@babel/helper-string-parser': 7.27.1
1471
977
'@babel/helper-validator-identifier': 7.28.5
1472
978
1473
-
'@braintree/sanitize-url@6.0.4':
1474
-
optional: true
1475
-
1476
-
'@braintree/sanitize-url@7.1.1': {}
1477
-
1478
-
'@chevrotain/cst-dts-gen@11.0.3':
1479
-
dependencies:
1480
-
'@chevrotain/gast': 11.0.3
1481
-
'@chevrotain/types': 11.0.3
1482
-
lodash-es: 4.17.21
1483
-
1484
-
'@chevrotain/gast@11.0.3':
1485
-
dependencies:
1486
-
'@chevrotain/types': 11.0.3
1487
-
lodash-es: 4.17.21
1488
-
1489
-
'@chevrotain/regexp-to-ast@11.0.3': {}
1490
-
1491
-
'@chevrotain/types@11.0.3': {}
1492
-
1493
-
'@chevrotain/utils@11.0.3': {}
1494
-
1495
979
'@docsearch/css@3.8.2': {}
1496
980
1497
-
'@docsearch/js@3.8.2(@algolia/client-search@5.40.0)(search-insights@2.17.3)':
981
+
'@docsearch/js@3.8.2(@algolia/client-search@5.46.0)(search-insights@2.17.3)':
1498
982
dependencies:
1499
-
'@docsearch/react': 3.8.2(@algolia/client-search@5.40.0)(search-insights@2.17.3)
1500
-
preact: 10.27.2
983
+
'@docsearch/react': 3.8.2(@algolia/client-search@5.46.0)(search-insights@2.17.3)
984
+
preact: 10.28.0
1501
985
transitivePeerDependencies:
1502
986
- '@algolia/client-search'
1503
987
- '@types/react'
···
1505
989
- react-dom
1506
990
- search-insights
1507
991
1508
-
'@docsearch/react@3.8.2(@algolia/client-search@5.40.0)(search-insights@2.17.3)':
992
+
'@docsearch/react@3.8.2(@algolia/client-search@5.46.0)(search-insights@2.17.3)':
1509
993
dependencies:
1510
-
'@algolia/autocomplete-core': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)(search-insights@2.17.3)
1511
-
'@algolia/autocomplete-preset-algolia': 1.17.7(@algolia/client-search@5.40.0)(algoliasearch@5.40.0)
994
+
'@algolia/autocomplete-core': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)(search-insights@2.17.3)
995
+
'@algolia/autocomplete-preset-algolia': 1.17.7(@algolia/client-search@5.46.0)(algoliasearch@5.46.0)
1512
996
'@docsearch/css': 3.8.2
1513
-
algoliasearch: 5.40.0
997
+
algoliasearch: 5.46.0
1514
998
optionalDependencies:
1515
999
search-insights: 2.17.3
1516
1000
transitivePeerDependencies:
···
1585
1069
'@esbuild/win32-x64@0.21.5':
1586
1070
optional: true
1587
1071
1588
-
'@giscus/vue@2.4.0(vue@3.5.25)':
1589
-
dependencies:
1590
-
giscus: 1.6.0
1591
-
vue: 3.5.25
1592
-
1593
-
'@iconify-json/logos@1.2.9':
1072
+
'@iconify-json/logos@1.2.10':
1594
1073
dependencies:
1595
1074
'@iconify/types': 2.0.0
1596
1075
1597
-
'@iconify-json/simple-icons@1.2.54':
1076
+
'@iconify-json/simple-icons@1.2.63':
1598
1077
dependencies:
1599
1078
'@iconify/types': 2.0.0
1600
1079
1601
-
'@iconify-json/vscode-icons@1.2.33':
1080
+
'@iconify-json/vscode-icons@1.2.37':
1602
1081
dependencies:
1603
1082
'@iconify/types': 2.0.0
1604
1083
1605
1084
'@iconify/types@2.0.0': {}
1606
1085
1607
-
'@iconify/utils@3.0.2':
1608
-
dependencies:
1609
-
'@antfu/install-pkg': 1.1.0
1610
-
'@antfu/utils': 9.3.0
1611
-
'@iconify/types': 2.0.0
1612
-
debug: 4.4.3
1613
-
globals: 15.15.0
1614
-
kolorist: 1.8.0
1615
-
local-pkg: 1.1.2
1616
-
mlly: 1.8.0
1617
-
transitivePeerDependencies:
1618
-
- supports-color
1619
-
1620
1086
'@iconify/utils@3.1.0':
1621
1087
dependencies:
1622
1088
'@antfu/install-pkg': 1.1.0
···
1625
1091
1626
1092
'@jridgewell/sourcemap-codec@1.5.5': {}
1627
1093
1628
-
'@lit-labs/ssr-dom-shim@1.4.0': {}
1629
-
1630
-
'@lit/reactive-element@2.1.1':
1631
-
dependencies:
1632
-
'@lit-labs/ssr-dom-shim': 1.4.0
1633
-
1634
-
'@mermaid-js/mermaid-mindmap@9.3.0':
1635
-
dependencies:
1636
-
'@braintree/sanitize-url': 6.0.4
1637
-
cytoscape: 3.33.1
1638
-
cytoscape-cose-bilkent: 4.1.0(cytoscape@3.33.1)
1639
-
cytoscape-fcose: 2.2.0(cytoscape@3.33.1)
1640
-
d3: 7.9.0
1641
-
khroma: 2.1.0
1642
-
non-layered-tidy-tree-layout: 2.0.2
1094
+
'@rollup/rollup-android-arm-eabi@4.53.5':
1643
1095
optional: true
1644
1096
1645
-
'@mermaid-js/parser@0.6.3':
1646
-
dependencies:
1647
-
langium: 3.3.1
1648
-
1649
-
'@rollup/rollup-android-arm-eabi@4.52.4':
1097
+
'@rollup/rollup-android-arm64@4.53.5':
1650
1098
optional: true
1651
1099
1652
-
'@rollup/rollup-android-arm64@4.52.4':
1100
+
'@rollup/rollup-darwin-arm64@4.53.5':
1653
1101
optional: true
1654
1102
1655
-
'@rollup/rollup-darwin-arm64@4.52.4':
1103
+
'@rollup/rollup-darwin-x64@4.53.5':
1656
1104
optional: true
1657
1105
1658
-
'@rollup/rollup-darwin-x64@4.52.4':
1106
+
'@rollup/rollup-freebsd-arm64@4.53.5':
1659
1107
optional: true
1660
1108
1661
-
'@rollup/rollup-freebsd-arm64@4.52.4':
1109
+
'@rollup/rollup-freebsd-x64@4.53.5':
1662
1110
optional: true
1663
1111
1664
-
'@rollup/rollup-freebsd-x64@4.52.4':
1112
+
'@rollup/rollup-linux-arm-gnueabihf@4.53.5':
1665
1113
optional: true
1666
1114
1667
-
'@rollup/rollup-linux-arm-gnueabihf@4.52.4':
1115
+
'@rollup/rollup-linux-arm-musleabihf@4.53.5':
1668
1116
optional: true
1669
1117
1670
-
'@rollup/rollup-linux-arm-musleabihf@4.52.4':
1118
+
'@rollup/rollup-linux-arm64-gnu@4.53.5':
1671
1119
optional: true
1672
1120
1673
-
'@rollup/rollup-linux-arm64-gnu@4.52.4':
1121
+
'@rollup/rollup-linux-arm64-musl@4.53.5':
1674
1122
optional: true
1675
1123
1676
-
'@rollup/rollup-linux-arm64-musl@4.52.4':
1677
-
optional: true
1678
-
1679
-
'@rollup/rollup-linux-loong64-gnu@4.52.4':
1124
+
'@rollup/rollup-linux-loong64-gnu@4.53.5':
1680
1125
optional: true
1681
1126
1682
-
'@rollup/rollup-linux-ppc64-gnu@4.52.4':
1127
+
'@rollup/rollup-linux-ppc64-gnu@4.53.5':
1683
1128
optional: true
1684
1129
1685
-
'@rollup/rollup-linux-riscv64-gnu@4.52.4':
1130
+
'@rollup/rollup-linux-riscv64-gnu@4.53.5':
1686
1131
optional: true
1687
1132
1688
-
'@rollup/rollup-linux-riscv64-musl@4.52.4':
1133
+
'@rollup/rollup-linux-riscv64-musl@4.53.5':
1689
1134
optional: true
1690
1135
1691
-
'@rollup/rollup-linux-s390x-gnu@4.52.4':
1136
+
'@rollup/rollup-linux-s390x-gnu@4.53.5':
1692
1137
optional: true
1693
1138
1694
-
'@rollup/rollup-linux-x64-gnu@4.52.4':
1139
+
'@rollup/rollup-linux-x64-gnu@4.53.5':
1695
1140
optional: true
1696
1141
1697
-
'@rollup/rollup-linux-x64-musl@4.52.4':
1142
+
'@rollup/rollup-linux-x64-musl@4.53.5':
1698
1143
optional: true
1699
1144
1700
-
'@rollup/rollup-openharmony-arm64@4.52.4':
1145
+
'@rollup/rollup-openharmony-arm64@4.53.5':
1701
1146
optional: true
1702
1147
1703
-
'@rollup/rollup-win32-arm64-msvc@4.52.4':
1148
+
'@rollup/rollup-win32-arm64-msvc@4.53.5':
1704
1149
optional: true
1705
1150
1706
-
'@rollup/rollup-win32-ia32-msvc@4.52.4':
1151
+
'@rollup/rollup-win32-ia32-msvc@4.53.5':
1707
1152
optional: true
1708
1153
1709
-
'@rollup/rollup-win32-x64-gnu@4.52.4':
1154
+
'@rollup/rollup-win32-x64-gnu@4.53.5':
1710
1155
optional: true
1711
1156
1712
-
'@rollup/rollup-win32-x64-msvc@4.52.4':
1157
+
'@rollup/rollup-win32-x64-msvc@4.53.5':
1713
1158
optional: true
1714
1159
1715
1160
'@shikijs/core@2.5.0':
···
1752
1197
1753
1198
'@shikijs/vscode-textmate@10.0.2': {}
1754
1199
1755
-
'@types/d3-array@3.2.2': {}
1756
-
1757
-
'@types/d3-axis@3.0.6':
1758
-
dependencies:
1759
-
'@types/d3-selection': 3.0.11
1760
-
1761
-
'@types/d3-brush@3.0.6':
1762
-
dependencies:
1763
-
'@types/d3-selection': 3.0.11
1764
-
1765
-
'@types/d3-chord@3.0.6': {}
1766
-
1767
-
'@types/d3-color@3.1.3': {}
1768
-
1769
-
'@types/d3-contour@3.0.6':
1770
-
dependencies:
1771
-
'@types/d3-array': 3.2.2
1772
-
'@types/geojson': 7946.0.16
1773
-
1774
-
'@types/d3-delaunay@6.0.4': {}
1775
-
1776
-
'@types/d3-dispatch@3.0.7': {}
1777
-
1778
-
'@types/d3-drag@3.0.7':
1779
-
dependencies:
1780
-
'@types/d3-selection': 3.0.11
1781
-
1782
-
'@types/d3-dsv@3.0.7': {}
1783
-
1784
-
'@types/d3-ease@3.0.2': {}
1785
-
1786
-
'@types/d3-fetch@3.0.7':
1787
-
dependencies:
1788
-
'@types/d3-dsv': 3.0.7
1789
-
1790
-
'@types/d3-force@3.0.10': {}
1791
-
1792
-
'@types/d3-format@3.0.4': {}
1793
-
1794
-
'@types/d3-geo@3.1.0':
1795
-
dependencies:
1796
-
'@types/geojson': 7946.0.16
1797
-
1798
-
'@types/d3-hierarchy@3.1.7': {}
1799
-
1800
-
'@types/d3-interpolate@3.0.4':
1801
-
dependencies:
1802
-
'@types/d3-color': 3.1.3
1803
-
1804
-
'@types/d3-path@3.1.1': {}
1805
-
1806
-
'@types/d3-polygon@3.0.2': {}
1807
-
1808
-
'@types/d3-quadtree@3.0.6': {}
1809
-
1810
-
'@types/d3-random@3.0.3': {}
1811
-
1812
-
'@types/d3-scale-chromatic@3.1.0': {}
1813
-
1814
-
'@types/d3-scale@4.0.9':
1815
-
dependencies:
1816
-
'@types/d3-time': 3.0.4
1817
-
1818
-
'@types/d3-selection@3.0.11': {}
1819
-
1820
-
'@types/d3-shape@3.1.7':
1821
-
dependencies:
1822
-
'@types/d3-path': 3.1.1
1823
-
1824
-
'@types/d3-time-format@4.0.3': {}
1825
-
1826
-
'@types/d3-time@3.0.4': {}
1827
-
1828
-
'@types/d3-timer@3.0.2': {}
1829
-
1830
-
'@types/d3-transition@3.0.9':
1831
-
dependencies:
1832
-
'@types/d3-selection': 3.0.11
1833
-
1834
-
'@types/d3-zoom@3.0.8':
1835
-
dependencies:
1836
-
'@types/d3-interpolate': 3.0.4
1837
-
'@types/d3-selection': 3.0.11
1838
-
1839
-
'@types/d3@7.4.3':
1840
-
dependencies:
1841
-
'@types/d3-array': 3.2.2
1842
-
'@types/d3-axis': 3.0.6
1843
-
'@types/d3-brush': 3.0.6
1844
-
'@types/d3-chord': 3.0.6
1845
-
'@types/d3-color': 3.1.3
1846
-
'@types/d3-contour': 3.0.6
1847
-
'@types/d3-delaunay': 6.0.4
1848
-
'@types/d3-dispatch': 3.0.7
1849
-
'@types/d3-drag': 3.0.7
1850
-
'@types/d3-dsv': 3.0.7
1851
-
'@types/d3-ease': 3.0.2
1852
-
'@types/d3-fetch': 3.0.7
1853
-
'@types/d3-force': 3.0.10
1854
-
'@types/d3-format': 3.0.4
1855
-
'@types/d3-geo': 3.1.0
1856
-
'@types/d3-hierarchy': 3.1.7
1857
-
'@types/d3-interpolate': 3.0.4
1858
-
'@types/d3-path': 3.1.1
1859
-
'@types/d3-polygon': 3.0.2
1860
-
'@types/d3-quadtree': 3.0.6
1861
-
'@types/d3-random': 3.0.3
1862
-
'@types/d3-scale': 4.0.9
1863
-
'@types/d3-scale-chromatic': 3.1.0
1864
-
'@types/d3-selection': 3.0.11
1865
-
'@types/d3-shape': 3.1.7
1866
-
'@types/d3-time': 3.0.4
1867
-
'@types/d3-time-format': 4.0.3
1868
-
'@types/d3-timer': 3.0.2
1869
-
'@types/d3-transition': 3.0.9
1870
-
'@types/d3-zoom': 3.0.8
1871
-
1872
1200
'@types/estree@1.0.8': {}
1873
-
1874
-
'@types/geojson@7946.0.16': {}
1875
1201
1876
1202
'@types/hast@3.0.4':
1877
1203
dependencies:
···
1890
1216
1891
1217
'@types/mdurl@2.0.0': {}
1892
1218
1893
-
'@types/trusted-types@2.0.7': {}
1894
-
1895
1219
'@types/unist@3.0.3': {}
1896
1220
1897
1221
'@types/web-bluetooth@0.0.21': {}
1898
1222
1899
1223
'@ungap/structured-clone@1.3.0': {}
1900
1224
1901
-
'@vitejs/plugin-vue@5.2.4(vite@5.4.20)(vue@3.5.25)':
1225
+
'@vitejs/plugin-vue@5.2.4(vite@5.4.21)(vue@3.5.26)':
1902
1226
dependencies:
1903
-
vite: 5.4.20
1904
-
vue: 3.5.25
1227
+
vite: 5.4.21
1228
+
vue: 3.5.26
1905
1229
1906
-
'@vue/compiler-core@3.5.25':
1230
+
'@vue/compiler-core@3.5.26':
1907
1231
dependencies:
1908
1232
'@babel/parser': 7.28.5
1909
-
'@vue/shared': 3.5.25
1910
-
entities: 4.5.0
1233
+
'@vue/shared': 3.5.26
1234
+
entities: 7.0.0
1911
1235
estree-walker: 2.0.2
1912
1236
source-map-js: 1.2.1
1913
1237
1914
-
'@vue/compiler-dom@3.5.25':
1238
+
'@vue/compiler-dom@3.5.26':
1915
1239
dependencies:
1916
-
'@vue/compiler-core': 3.5.25
1917
-
'@vue/shared': 3.5.25
1240
+
'@vue/compiler-core': 3.5.26
1241
+
'@vue/shared': 3.5.26
1918
1242
1919
-
'@vue/compiler-sfc@3.5.25':
1243
+
'@vue/compiler-sfc@3.5.26':
1920
1244
dependencies:
1921
1245
'@babel/parser': 7.28.5
1922
-
'@vue/compiler-core': 3.5.25
1923
-
'@vue/compiler-dom': 3.5.25
1924
-
'@vue/compiler-ssr': 3.5.25
1925
-
'@vue/shared': 3.5.25
1246
+
'@vue/compiler-core': 3.5.26
1247
+
'@vue/compiler-dom': 3.5.26
1248
+
'@vue/compiler-ssr': 3.5.26
1249
+
'@vue/shared': 3.5.26
1926
1250
estree-walker: 2.0.2
1927
1251
magic-string: 0.30.21
1928
1252
postcss: 8.5.6
1929
1253
source-map-js: 1.2.1
1930
1254
1931
-
'@vue/compiler-ssr@3.5.25':
1255
+
'@vue/compiler-ssr@3.5.26':
1932
1256
dependencies:
1933
-
'@vue/compiler-dom': 3.5.25
1934
-
'@vue/shared': 3.5.25
1257
+
'@vue/compiler-dom': 3.5.26
1258
+
'@vue/shared': 3.5.26
1935
1259
1936
-
'@vue/devtools-api@7.7.7':
1260
+
'@vue/devtools-api@7.7.9':
1937
1261
dependencies:
1938
-
'@vue/devtools-kit': 7.7.7
1262
+
'@vue/devtools-kit': 7.7.9
1939
1263
1940
-
'@vue/devtools-kit@7.7.7':
1264
+
'@vue/devtools-kit@7.7.9':
1941
1265
dependencies:
1942
-
'@vue/devtools-shared': 7.7.7
1943
-
birpc: 2.6.1
1266
+
'@vue/devtools-shared': 7.7.9
1267
+
birpc: 2.9.0
1944
1268
hookable: 5.5.3
1945
1269
mitt: 3.0.1
1946
1270
perfect-debounce: 1.0.0
1947
1271
speakingurl: 14.0.1
1948
-
superjson: 2.2.2
1272
+
superjson: 2.2.6
1949
1273
1950
-
'@vue/devtools-shared@7.7.7':
1274
+
'@vue/devtools-shared@7.7.9':
1951
1275
dependencies:
1952
1276
rfdc: 1.4.1
1953
1277
1954
-
'@vue/reactivity@3.5.25':
1278
+
'@vue/reactivity@3.5.26':
1955
1279
dependencies:
1956
-
'@vue/shared': 3.5.25
1280
+
'@vue/shared': 3.5.26
1957
1281
1958
-
'@vue/runtime-core@3.5.25':
1282
+
'@vue/runtime-core@3.5.26':
1959
1283
dependencies:
1960
-
'@vue/reactivity': 3.5.25
1961
-
'@vue/shared': 3.5.25
1284
+
'@vue/reactivity': 3.5.26
1285
+
'@vue/shared': 3.5.26
1962
1286
1963
-
'@vue/runtime-dom@3.5.25':
1287
+
'@vue/runtime-dom@3.5.26':
1964
1288
dependencies:
1965
-
'@vue/reactivity': 3.5.25
1966
-
'@vue/runtime-core': 3.5.25
1967
-
'@vue/shared': 3.5.25
1289
+
'@vue/reactivity': 3.5.26
1290
+
'@vue/runtime-core': 3.5.26
1291
+
'@vue/shared': 3.5.26
1968
1292
csstype: 3.2.3
1969
1293
1970
-
'@vue/server-renderer@3.5.25(vue@3.5.25)':
1294
+
'@vue/server-renderer@3.5.26(vue@3.5.26)':
1971
1295
dependencies:
1972
-
'@vue/compiler-ssr': 3.5.25
1973
-
'@vue/shared': 3.5.25
1974
-
vue: 3.5.25
1296
+
'@vue/compiler-ssr': 3.5.26
1297
+
'@vue/shared': 3.5.26
1298
+
vue: 3.5.26
1975
1299
1976
-
'@vue/shared@3.5.22': {}
1300
+
'@vue/shared@3.5.25': {}
1977
1301
1978
-
'@vue/shared@3.5.25': {}
1302
+
'@vue/shared@3.5.26': {}
1979
1303
1980
1304
'@vueuse/core@12.8.2':
1981
1305
dependencies:
1982
1306
'@types/web-bluetooth': 0.0.21
1983
1307
'@vueuse/metadata': 12.8.2
1984
1308
'@vueuse/shared': 12.8.2
1985
-
vue: 3.5.25
1309
+
vue: 3.5.26
1986
1310
transitivePeerDependencies:
1987
1311
- typescript
1988
1312
1989
-
'@vueuse/integrations@12.8.2(focus-trap@7.6.5)':
1313
+
'@vueuse/integrations@12.8.2(focus-trap@7.6.6)':
1990
1314
dependencies:
1991
1315
'@vueuse/core': 12.8.2
1992
1316
'@vueuse/shared': 12.8.2
1993
-
vue: 3.5.25
1317
+
vue: 3.5.26
1994
1318
optionalDependencies:
1995
-
focus-trap: 7.6.5
1319
+
focus-trap: 7.6.6
1996
1320
transitivePeerDependencies:
1997
1321
- typescript
1998
1322
···
2000
1324
2001
1325
'@vueuse/shared@12.8.2':
2002
1326
dependencies:
2003
-
vue: 3.5.25
1327
+
vue: 3.5.26
2004
1328
transitivePeerDependencies:
2005
1329
- typescript
2006
1330
2007
1331
acorn@8.15.0: {}
2008
1332
2009
-
algoliasearch@5.40.0:
1333
+
algoliasearch@5.46.0:
2010
1334
dependencies:
2011
-
'@algolia/abtesting': 1.6.0
2012
-
'@algolia/client-abtesting': 5.40.0
2013
-
'@algolia/client-analytics': 5.40.0
2014
-
'@algolia/client-common': 5.40.0
2015
-
'@algolia/client-insights': 5.40.0
2016
-
'@algolia/client-personalization': 5.40.0
2017
-
'@algolia/client-query-suggestions': 5.40.0
2018
-
'@algolia/client-search': 5.40.0
2019
-
'@algolia/ingestion': 1.40.0
2020
-
'@algolia/monitoring': 1.40.0
2021
-
'@algolia/recommend': 5.40.0
2022
-
'@algolia/requester-browser-xhr': 5.40.0
2023
-
'@algolia/requester-fetch': 5.40.0
2024
-
'@algolia/requester-node-http': 5.40.0
1335
+
'@algolia/abtesting': 1.12.0
1336
+
'@algolia/client-abtesting': 5.46.0
1337
+
'@algolia/client-analytics': 5.46.0
1338
+
'@algolia/client-common': 5.46.0
1339
+
'@algolia/client-insights': 5.46.0
1340
+
'@algolia/client-personalization': 5.46.0
1341
+
'@algolia/client-query-suggestions': 5.46.0
1342
+
'@algolia/client-search': 5.46.0
1343
+
'@algolia/ingestion': 1.46.0
1344
+
'@algolia/monitoring': 1.46.0
1345
+
'@algolia/recommend': 5.46.0
1346
+
'@algolia/requester-browser-xhr': 5.46.0
1347
+
'@algolia/requester-fetch': 5.46.0
1348
+
'@algolia/requester-node-http': 5.46.0
2025
1349
2026
-
birpc@2.6.1: {}
1350
+
birpc@2.9.0: {}
2027
1351
2028
1352
ccount@2.0.1: {}
2029
1353
···
2031
1355
2032
1356
character-entities-legacy@3.0.0: {}
2033
1357
2034
-
chevrotain-allstar@0.3.1(chevrotain@11.0.3):
2035
-
dependencies:
2036
-
chevrotain: 11.0.3
2037
-
lodash-es: 4.17.21
2038
-
2039
-
chevrotain@11.0.3:
2040
-
dependencies:
2041
-
'@chevrotain/cst-dts-gen': 11.0.3
2042
-
'@chevrotain/gast': 11.0.3
2043
-
'@chevrotain/regexp-to-ast': 11.0.3
2044
-
'@chevrotain/types': 11.0.3
2045
-
'@chevrotain/utils': 11.0.3
2046
-
lodash-es: 4.17.21
2047
-
2048
1358
comma-separated-tokens@2.0.3: {}
2049
-
2050
-
commander@7.2.0: {}
2051
-
2052
-
commander@8.3.0: {}
2053
1359
2054
1360
confbox@0.1.8: {}
2055
1361
2056
-
confbox@0.2.2: {}
2057
-
2058
-
copy-anything@3.0.5:
2059
-
dependencies:
2060
-
is-what: 4.1.16
2061
-
2062
-
cose-base@1.0.3:
1362
+
copy-anything@4.0.5:
2063
1363
dependencies:
2064
-
layout-base: 1.0.2
2065
-
2066
-
cose-base@2.2.0:
2067
-
dependencies:
2068
-
layout-base: 2.0.1
1364
+
is-what: 5.5.0
2069
1365
2070
1366
csstype@3.2.3: {}
2071
1367
2072
-
cytoscape-cose-bilkent@4.1.0(cytoscape@3.33.1):
2073
-
dependencies:
2074
-
cose-base: 1.0.3
2075
-
cytoscape: 3.33.1
2076
-
2077
-
cytoscape-fcose@2.2.0(cytoscape@3.33.1):
2078
-
dependencies:
2079
-
cose-base: 2.2.0
2080
-
cytoscape: 3.33.1
2081
-
2082
-
cytoscape@3.33.1: {}
2083
-
2084
-
d3-array@2.12.1:
2085
-
dependencies:
2086
-
internmap: 1.0.1
2087
-
2088
-
d3-array@3.2.4:
2089
-
dependencies:
2090
-
internmap: 2.0.3
2091
-
2092
-
d3-axis@3.0.0: {}
2093
-
2094
-
d3-brush@3.0.0:
2095
-
dependencies:
2096
-
d3-dispatch: 3.0.1
2097
-
d3-drag: 3.0.0
2098
-
d3-interpolate: 3.0.1
2099
-
d3-selection: 3.0.0
2100
-
d3-transition: 3.0.1(d3-selection@3.0.0)
2101
-
2102
-
d3-chord@3.0.1:
2103
-
dependencies:
2104
-
d3-path: 3.1.0
2105
-
2106
-
d3-color@3.1.0: {}
2107
-
2108
-
d3-contour@4.0.2:
2109
-
dependencies:
2110
-
d3-array: 3.2.4
2111
-
2112
-
d3-delaunay@6.0.4:
2113
-
dependencies:
2114
-
delaunator: 5.0.1
2115
-
2116
-
d3-dispatch@3.0.1: {}
2117
-
2118
-
d3-drag@3.0.0:
2119
-
dependencies:
2120
-
d3-dispatch: 3.0.1
2121
-
d3-selection: 3.0.0
2122
-
2123
-
d3-dsv@3.0.1:
2124
-
dependencies:
2125
-
commander: 7.2.0
2126
-
iconv-lite: 0.6.3
2127
-
rw: 1.3.3
2128
-
2129
-
d3-ease@3.0.1: {}
2130
-
2131
-
d3-fetch@3.0.1:
2132
-
dependencies:
2133
-
d3-dsv: 3.0.1
2134
-
2135
-
d3-force@3.0.0:
2136
-
dependencies:
2137
-
d3-dispatch: 3.0.1
2138
-
d3-quadtree: 3.0.1
2139
-
d3-timer: 3.0.1
2140
-
2141
-
d3-format@3.1.0: {}
2142
-
2143
-
d3-geo@3.1.1:
2144
-
dependencies:
2145
-
d3-array: 3.2.4
2146
-
2147
-
d3-hierarchy@3.1.2: {}
2148
-
2149
-
d3-interpolate@3.0.1:
2150
-
dependencies:
2151
-
d3-color: 3.1.0
2152
-
2153
-
d3-path@1.0.9: {}
2154
-
2155
-
d3-path@3.1.0: {}
2156
-
2157
-
d3-polygon@3.0.1: {}
2158
-
2159
-
d3-quadtree@3.0.1: {}
2160
-
2161
-
d3-random@3.0.1: {}
2162
-
2163
-
d3-sankey@0.12.3:
2164
-
dependencies:
2165
-
d3-array: 2.12.1
2166
-
d3-shape: 1.3.7
2167
-
2168
-
d3-scale-chromatic@3.1.0:
2169
-
dependencies:
2170
-
d3-color: 3.1.0
2171
-
d3-interpolate: 3.0.1
2172
-
2173
-
d3-scale@4.0.2:
2174
-
dependencies:
2175
-
d3-array: 3.2.4
2176
-
d3-format: 3.1.0
2177
-
d3-interpolate: 3.0.1
2178
-
d3-time: 3.1.0
2179
-
d3-time-format: 4.1.0
2180
-
2181
-
d3-selection@3.0.0: {}
2182
-
2183
-
d3-shape@1.3.7:
2184
-
dependencies:
2185
-
d3-path: 1.0.9
2186
-
2187
-
d3-shape@3.2.0:
2188
-
dependencies:
2189
-
d3-path: 3.1.0
2190
-
2191
-
d3-time-format@4.1.0:
2192
-
dependencies:
2193
-
d3-time: 3.1.0
2194
-
2195
-
d3-time@3.1.0:
2196
-
dependencies:
2197
-
d3-array: 3.2.4
2198
-
2199
-
d3-timer@3.0.1: {}
2200
-
2201
-
d3-transition@3.0.1(d3-selection@3.0.0):
2202
-
dependencies:
2203
-
d3-color: 3.1.0
2204
-
d3-dispatch: 3.0.1
2205
-
d3-ease: 3.0.1
2206
-
d3-interpolate: 3.0.1
2207
-
d3-selection: 3.0.0
2208
-
d3-timer: 3.0.1
2209
-
2210
-
d3-zoom@3.0.0:
2211
-
dependencies:
2212
-
d3-dispatch: 3.0.1
2213
-
d3-drag: 3.0.0
2214
-
d3-interpolate: 3.0.1
2215
-
d3-selection: 3.0.0
2216
-
d3-transition: 3.0.1(d3-selection@3.0.0)
2217
-
2218
-
d3@7.9.0:
2219
-
dependencies:
2220
-
d3-array: 3.2.4
2221
-
d3-axis: 3.0.0
2222
-
d3-brush: 3.0.0
2223
-
d3-chord: 3.0.1
2224
-
d3-color: 3.1.0
2225
-
d3-contour: 4.0.2
2226
-
d3-delaunay: 6.0.4
2227
-
d3-dispatch: 3.0.1
2228
-
d3-drag: 3.0.0
2229
-
d3-dsv: 3.0.1
2230
-
d3-ease: 3.0.1
2231
-
d3-fetch: 3.0.1
2232
-
d3-force: 3.0.0
2233
-
d3-format: 3.1.0
2234
-
d3-geo: 3.1.1
2235
-
d3-hierarchy: 3.1.2
2236
-
d3-interpolate: 3.0.1
2237
-
d3-path: 3.1.0
2238
-
d3-polygon: 3.0.1
2239
-
d3-quadtree: 3.0.1
2240
-
d3-random: 3.0.1
2241
-
d3-scale: 4.0.2
2242
-
d3-scale-chromatic: 3.1.0
2243
-
d3-selection: 3.0.0
2244
-
d3-shape: 3.2.0
2245
-
d3-time: 3.1.0
2246
-
d3-time-format: 4.1.0
2247
-
d3-timer: 3.0.1
2248
-
d3-transition: 3.0.1(d3-selection@3.0.0)
2249
-
d3-zoom: 3.0.0
2250
-
2251
-
dagre-d3-es@7.0.13:
2252
-
dependencies:
2253
-
d3: 7.9.0
2254
-
lodash-es: 4.17.21
2255
-
2256
-
dayjs@1.11.19: {}
2257
-
2258
-
debug@4.4.3:
2259
-
dependencies:
2260
-
ms: 2.1.3
2261
-
2262
-
delaunator@5.0.1:
2263
-
dependencies:
2264
-
robust-predicates: 3.0.2
2265
-
2266
1368
dequal@2.0.3: {}
2267
1369
2268
1370
devlop@1.1.0:
2269
1371
dependencies:
2270
1372
dequal: 2.0.3
2271
1373
2272
-
dompurify@3.3.0:
2273
-
optionalDependencies:
2274
-
'@types/trusted-types': 2.0.7
2275
-
2276
1374
emoji-regex-xs@1.0.0: {}
2277
1375
2278
-
entities@4.5.0: {}
1376
+
entities@7.0.0: {}
2279
1377
2280
1378
esbuild@0.21.5:
2281
1379
optionalDependencies:
···
2305
1403
2306
1404
estree-walker@2.0.2: {}
2307
1405
2308
-
exsolve@1.0.7: {}
2309
-
2310
-
focus-trap@7.6.5:
1406
+
focus-trap@7.6.6:
2311
1407
dependencies:
2312
-
tabbable: 6.2.0
1408
+
tabbable: 6.3.0
2313
1409
2314
1410
fsevents@2.3.3:
2315
1411
optional: true
2316
1412
2317
-
giscus@1.6.0:
2318
-
dependencies:
2319
-
lit: 3.3.1
2320
-
2321
-
globals@15.15.0: {}
2322
-
2323
-
hachure-fill@0.5.2: {}
2324
-
2325
1413
hast-util-to-html@9.0.5:
2326
1414
dependencies:
2327
1415
'@types/hast': 3.0.4
···
2330
1418
comma-separated-tokens: 2.0.3
2331
1419
hast-util-whitespace: 3.0.0
2332
1420
html-void-elements: 3.0.0
2333
-
mdast-util-to-hast: 13.2.0
1421
+
mdast-util-to-hast: 13.2.1
2334
1422
property-information: 7.1.0
2335
1423
space-separated-tokens: 2.0.2
2336
1424
stringify-entities: 4.0.4
···
2344
1432
2345
1433
html-void-elements@3.0.0: {}
2346
1434
2347
-
iconv-lite@0.6.3:
2348
-
dependencies:
2349
-
safer-buffer: 2.1.2
2350
-
2351
-
internmap@1.0.1: {}
2352
-
2353
-
internmap@2.0.3: {}
2354
-
2355
-
is-what@4.1.16: {}
2356
-
2357
-
katex@0.16.25:
2358
-
dependencies:
2359
-
commander: 8.3.0
2360
-
2361
-
khroma@2.1.0: {}
2362
-
2363
-
kolorist@1.8.0: {}
2364
-
2365
-
langium@3.3.1:
2366
-
dependencies:
2367
-
chevrotain: 11.0.3
2368
-
chevrotain-allstar: 0.3.1(chevrotain@11.0.3)
2369
-
vscode-languageserver: 9.0.1
2370
-
vscode-languageserver-textdocument: 1.0.12
2371
-
vscode-uri: 3.0.8
2372
-
2373
-
layout-base@1.0.2: {}
2374
-
2375
-
layout-base@2.0.1: {}
2376
-
2377
-
lit-element@4.2.1:
2378
-
dependencies:
2379
-
'@lit-labs/ssr-dom-shim': 1.4.0
2380
-
'@lit/reactive-element': 2.1.1
2381
-
lit-html: 3.3.1
2382
-
2383
-
lit-html@3.3.1:
2384
-
dependencies:
2385
-
'@types/trusted-types': 2.0.7
2386
-
2387
-
lit@3.3.1:
2388
-
dependencies:
2389
-
'@lit/reactive-element': 2.1.1
2390
-
lit-element: 4.2.1
2391
-
lit-html: 3.3.1
2392
-
2393
-
local-pkg@1.1.2:
2394
-
dependencies:
2395
-
mlly: 1.8.0
2396
-
pkg-types: 2.3.0
2397
-
quansync: 0.2.11
2398
-
2399
-
lodash-es@4.17.21: {}
1435
+
is-what@5.5.0: {}
2400
1436
2401
1437
magic-string@0.30.21:
2402
1438
dependencies:
···
2406
1442
2407
1443
markdown-it-footnote@4.0.0: {}
2408
1444
2409
-
marked@16.4.2: {}
2410
-
2411
-
mdast-util-to-hast@13.2.0:
1445
+
mdast-util-to-hast@13.2.1:
2412
1446
dependencies:
2413
1447
'@types/hast': 3.0.4
2414
1448
'@types/mdast': 4.0.4
···
2420
1454
unist-util-visit: 5.0.0
2421
1455
vfile: 6.0.3
2422
1456
2423
-
mermaid@11.12.2:
2424
-
dependencies:
2425
-
'@braintree/sanitize-url': 7.1.1
2426
-
'@iconify/utils': 3.1.0
2427
-
'@mermaid-js/parser': 0.6.3
2428
-
'@types/d3': 7.4.3
2429
-
cytoscape: 3.33.1
2430
-
cytoscape-cose-bilkent: 4.1.0(cytoscape@3.33.1)
2431
-
cytoscape-fcose: 2.2.0(cytoscape@3.33.1)
2432
-
d3: 7.9.0
2433
-
d3-sankey: 0.12.3
2434
-
dagre-d3-es: 7.0.13
2435
-
dayjs: 1.11.19
2436
-
dompurify: 3.3.0
2437
-
katex: 0.16.25
2438
-
khroma: 2.1.0
2439
-
lodash-es: 4.17.21
2440
-
marked: 16.4.2
2441
-
roughjs: 4.6.6
2442
-
stylis: 4.3.6
2443
-
ts-dedent: 2.2.0
2444
-
uuid: 11.1.0
2445
-
2446
1457
micromark-util-character@2.1.1:
2447
1458
dependencies:
2448
1459
micromark-util-symbol: 2.0.1
···
2471
1482
pkg-types: 1.3.1
2472
1483
ufo: 1.6.1
2473
1484
2474
-
ms@2.1.3: {}
2475
-
2476
1485
nanoid@3.3.11: {}
2477
-
2478
-
non-layered-tidy-tree-layout@2.0.2:
2479
-
optional: true
2480
1486
2481
1487
oniguruma-to-es@3.1.1:
2482
1488
dependencies:
2483
1489
emoji-regex-xs: 1.0.0
2484
-
regex: 6.0.1
1490
+
regex: 6.1.0
2485
1491
regex-recursion: 6.0.2
2486
1492
2487
1493
package-manager-detector@1.6.0: {}
2488
-
2489
-
path-data-parser@0.1.0: {}
2490
1494
2491
1495
pathe@2.0.3: {}
2492
1496
···
2500
1504
mlly: 1.8.0
2501
1505
pathe: 2.0.3
2502
1506
2503
-
pkg-types@2.3.0:
2504
-
dependencies:
2505
-
confbox: 0.2.2
2506
-
exsolve: 1.0.7
2507
-
pathe: 2.0.3
2508
-
2509
-
points-on-curve@0.2.0: {}
2510
-
2511
-
points-on-path@0.2.1:
2512
-
dependencies:
2513
-
path-data-parser: 0.1.0
2514
-
points-on-curve: 0.2.0
2515
-
2516
1507
postcss@8.5.6:
2517
1508
dependencies:
2518
1509
nanoid: 3.3.11
2519
1510
picocolors: 1.1.1
2520
1511
source-map-js: 1.2.1
2521
1512
2522
-
preact@10.27.2: {}
1513
+
preact@10.28.0: {}
2523
1514
2524
1515
property-information@7.1.0: {}
2525
-
2526
-
quansync@0.2.11: {}
2527
1516
2528
1517
regex-recursion@6.0.2:
2529
1518
dependencies:
···
2531
1520
2532
1521
regex-utilities@2.3.0: {}
2533
1522
2534
-
regex@6.0.1:
1523
+
regex@6.1.0:
2535
1524
dependencies:
2536
1525
regex-utilities: 2.3.0
2537
1526
2538
1527
rfdc@1.4.1: {}
2539
1528
2540
-
robust-predicates@3.0.2: {}
2541
-
2542
-
rollup@4.52.4:
1529
+
rollup@4.53.5:
2543
1530
dependencies:
2544
1531
'@types/estree': 1.0.8
2545
1532
optionalDependencies:
2546
-
'@rollup/rollup-android-arm-eabi': 4.52.4
2547
-
'@rollup/rollup-android-arm64': 4.52.4
2548
-
'@rollup/rollup-darwin-arm64': 4.52.4
2549
-
'@rollup/rollup-darwin-x64': 4.52.4
2550
-
'@rollup/rollup-freebsd-arm64': 4.52.4
2551
-
'@rollup/rollup-freebsd-x64': 4.52.4
2552
-
'@rollup/rollup-linux-arm-gnueabihf': 4.52.4
2553
-
'@rollup/rollup-linux-arm-musleabihf': 4.52.4
2554
-
'@rollup/rollup-linux-arm64-gnu': 4.52.4
2555
-
'@rollup/rollup-linux-arm64-musl': 4.52.4
2556
-
'@rollup/rollup-linux-loong64-gnu': 4.52.4
2557
-
'@rollup/rollup-linux-ppc64-gnu': 4.52.4
2558
-
'@rollup/rollup-linux-riscv64-gnu': 4.52.4
2559
-
'@rollup/rollup-linux-riscv64-musl': 4.52.4
2560
-
'@rollup/rollup-linux-s390x-gnu': 4.52.4
2561
-
'@rollup/rollup-linux-x64-gnu': 4.52.4
2562
-
'@rollup/rollup-linux-x64-musl': 4.52.4
2563
-
'@rollup/rollup-openharmony-arm64': 4.52.4
2564
-
'@rollup/rollup-win32-arm64-msvc': 4.52.4
2565
-
'@rollup/rollup-win32-ia32-msvc': 4.52.4
2566
-
'@rollup/rollup-win32-x64-gnu': 4.52.4
2567
-
'@rollup/rollup-win32-x64-msvc': 4.52.4
1533
+
'@rollup/rollup-android-arm-eabi': 4.53.5
1534
+
'@rollup/rollup-android-arm64': 4.53.5
1535
+
'@rollup/rollup-darwin-arm64': 4.53.5
1536
+
'@rollup/rollup-darwin-x64': 4.53.5
1537
+
'@rollup/rollup-freebsd-arm64': 4.53.5
1538
+
'@rollup/rollup-freebsd-x64': 4.53.5
1539
+
'@rollup/rollup-linux-arm-gnueabihf': 4.53.5
1540
+
'@rollup/rollup-linux-arm-musleabihf': 4.53.5
1541
+
'@rollup/rollup-linux-arm64-gnu': 4.53.5
1542
+
'@rollup/rollup-linux-arm64-musl': 4.53.5
1543
+
'@rollup/rollup-linux-loong64-gnu': 4.53.5
1544
+
'@rollup/rollup-linux-ppc64-gnu': 4.53.5
1545
+
'@rollup/rollup-linux-riscv64-gnu': 4.53.5
1546
+
'@rollup/rollup-linux-riscv64-musl': 4.53.5
1547
+
'@rollup/rollup-linux-s390x-gnu': 4.53.5
1548
+
'@rollup/rollup-linux-x64-gnu': 4.53.5
1549
+
'@rollup/rollup-linux-x64-musl': 4.53.5
1550
+
'@rollup/rollup-openharmony-arm64': 4.53.5
1551
+
'@rollup/rollup-win32-arm64-msvc': 4.53.5
1552
+
'@rollup/rollup-win32-ia32-msvc': 4.53.5
1553
+
'@rollup/rollup-win32-x64-gnu': 4.53.5
1554
+
'@rollup/rollup-win32-x64-msvc': 4.53.5
2568
1555
fsevents: 2.3.3
2569
-
2570
-
roughjs@4.6.6:
2571
-
dependencies:
2572
-
hachure-fill: 0.5.2
2573
-
path-data-parser: 0.1.0
2574
-
points-on-curve: 0.2.0
2575
-
points-on-path: 0.2.1
2576
-
2577
-
rw@1.3.3: {}
2578
-
2579
-
safer-buffer@2.1.2: {}
2580
1556
2581
1557
search-insights@2.17.3: {}
2582
1558
···
2602
1578
character-entities-html4: 2.1.0
2603
1579
character-entities-legacy: 3.0.0
2604
1580
2605
-
stylis@4.3.6: {}
2606
-
2607
-
superjson@2.2.2:
1581
+
superjson@2.2.6:
2608
1582
dependencies:
2609
-
copy-anything: 3.0.5
1583
+
copy-anything: 4.0.5
2610
1584
2611
-
tabbable@6.2.0: {}
1585
+
tabbable@6.3.0: {}
2612
1586
2613
1587
tinyexec@1.0.2: {}
2614
1588
2615
1589
trim-lines@3.0.1: {}
2616
1590
2617
-
ts-dedent@2.2.0: {}
2618
-
2619
1591
ufo@1.6.1: {}
2620
1592
2621
-
unist-util-is@6.0.0:
1593
+
unist-util-is@6.0.1:
2622
1594
dependencies:
2623
1595
'@types/unist': 3.0.3
2624
1596
···
2630
1602
dependencies:
2631
1603
'@types/unist': 3.0.3
2632
1604
2633
-
unist-util-visit-parents@6.0.1:
1605
+
unist-util-visit-parents@6.0.2:
2634
1606
dependencies:
2635
1607
'@types/unist': 3.0.3
2636
-
unist-util-is: 6.0.0
1608
+
unist-util-is: 6.0.1
2637
1609
2638
1610
unist-util-visit@5.0.0:
2639
1611
dependencies:
2640
1612
'@types/unist': 3.0.3
2641
-
unist-util-is: 6.0.0
2642
-
unist-util-visit-parents: 6.0.1
2643
-
2644
-
uuid@11.1.0: {}
1613
+
unist-util-is: 6.0.1
1614
+
unist-util-visit-parents: 6.0.2
2645
1615
2646
1616
vfile-message@4.0.3:
2647
1617
dependencies:
···
2653
1623
'@types/unist': 3.0.3
2654
1624
vfile-message: 4.0.3
2655
1625
2656
-
vite@5.4.20:
1626
+
vite@5.4.21:
2657
1627
dependencies:
2658
1628
esbuild: 0.21.5
2659
1629
postcss: 8.5.6
2660
-
rollup: 4.52.4
1630
+
rollup: 4.53.5
2661
1631
optionalDependencies:
2662
1632
fsevents: 2.3.3
2663
1633
2664
-
vitepress-plugin-comment-with-giscus@1.1.15(vue@3.5.25):
2665
-
dependencies:
2666
-
'@giscus/vue': 2.4.0(vue@3.5.25)
2667
-
transitivePeerDependencies:
2668
-
- vue
2669
-
2670
-
vitepress-plugin-group-icons@1.6.5(vite@5.4.20):
2671
-
dependencies:
2672
-
'@iconify-json/logos': 1.2.9
2673
-
'@iconify-json/vscode-icons': 1.2.33
2674
-
'@iconify/utils': 3.0.2
2675
-
optionalDependencies:
2676
-
vite: 5.4.20
2677
-
transitivePeerDependencies:
2678
-
- supports-color
2679
-
2680
-
vitepress-plugin-mermaid@2.0.17(mermaid@11.12.2)(vitepress@1.6.4(@algolia/client-search@5.40.0)(postcss@8.5.6)(search-insights@2.17.3)):
1634
+
vitepress-plugin-group-icons@1.6.5(vite@5.4.21):
2681
1635
dependencies:
2682
-
mermaid: 11.12.2
2683
-
vitepress: 1.6.4(@algolia/client-search@5.40.0)(postcss@8.5.6)(search-insights@2.17.3)
1636
+
'@iconify-json/logos': 1.2.10
1637
+
'@iconify-json/vscode-icons': 1.2.37
1638
+
'@iconify/utils': 3.1.0
2684
1639
optionalDependencies:
2685
-
'@mermaid-js/mermaid-mindmap': 9.3.0
1640
+
vite: 5.4.21
2686
1641
2687
-
vitepress@1.6.4(@algolia/client-search@5.40.0)(postcss@8.5.6)(search-insights@2.17.3):
1642
+
vitepress@1.6.4(@algolia/client-search@5.46.0)(postcss@8.5.6)(search-insights@2.17.3):
2688
1643
dependencies:
2689
1644
'@docsearch/css': 3.8.2
2690
-
'@docsearch/js': 3.8.2(@algolia/client-search@5.40.0)(search-insights@2.17.3)
2691
-
'@iconify-json/simple-icons': 1.2.54
1645
+
'@docsearch/js': 3.8.2(@algolia/client-search@5.46.0)(search-insights@2.17.3)
1646
+
'@iconify-json/simple-icons': 1.2.63
2692
1647
'@shikijs/core': 2.5.0
2693
1648
'@shikijs/transformers': 2.5.0
2694
1649
'@shikijs/types': 2.5.0
2695
1650
'@types/markdown-it': 14.1.2
2696
-
'@vitejs/plugin-vue': 5.2.4(vite@5.4.20)(vue@3.5.25)
2697
-
'@vue/devtools-api': 7.7.7
2698
-
'@vue/shared': 3.5.22
1651
+
'@vitejs/plugin-vue': 5.2.4(vite@5.4.21)(vue@3.5.26)
1652
+
'@vue/devtools-api': 7.7.9
1653
+
'@vue/shared': 3.5.25
2699
1654
'@vueuse/core': 12.8.2
2700
-
'@vueuse/integrations': 12.8.2(focus-trap@7.6.5)
2701
-
focus-trap: 7.6.5
1655
+
'@vueuse/integrations': 12.8.2(focus-trap@7.6.6)
1656
+
focus-trap: 7.6.6
2702
1657
mark.js: 8.11.1
2703
1658
minisearch: 7.2.0
2704
1659
shiki: 2.5.0
2705
-
vite: 5.4.20
2706
-
vue: 3.5.25
1660
+
vite: 5.4.21
1661
+
vue: 3.5.26
2707
1662
optionalDependencies:
2708
1663
postcss: 8.5.6
2709
1664
transitivePeerDependencies:
···
2733
1688
- typescript
2734
1689
- universal-cookie
2735
1690
2736
-
vscode-jsonrpc@8.2.0: {}
2737
-
2738
-
vscode-languageserver-protocol@3.17.5:
2739
-
dependencies:
2740
-
vscode-jsonrpc: 8.2.0
2741
-
vscode-languageserver-types: 3.17.5
2742
-
2743
-
vscode-languageserver-textdocument@1.0.12: {}
2744
-
2745
-
vscode-languageserver-types@3.17.5: {}
2746
-
2747
-
vscode-languageserver@9.0.1:
2748
-
dependencies:
2749
-
vscode-languageserver-protocol: 3.17.5
2750
-
2751
-
vscode-uri@3.0.8: {}
2752
-
2753
-
vue@3.5.25:
1691
+
vue@3.5.26:
2754
1692
dependencies:
2755
-
'@vue/compiler-dom': 3.5.25
2756
-
'@vue/compiler-sfc': 3.5.25
2757
-
'@vue/runtime-dom': 3.5.25
2758
-
'@vue/server-renderer': 3.5.25(vue@3.5.25)
2759
-
'@vue/shared': 3.5.25
1693
+
'@vue/compiler-dom': 3.5.26
1694
+
'@vue/compiler-sfc': 3.5.26
1695
+
'@vue/runtime-dom': 3.5.26
1696
+
'@vue/server-renderer': 3.5.26(vue@3.5.26)
1697
+
'@vue/shared': 3.5.26
2760
1698
2761
1699
zwitch@2.0.4: {}
+1
-1
doc/reference/errors.md
+1
-1
doc/reference/errors.md
+19
-1
doc/reference/meta.md
+19
-1
doc/reference/meta.md
···
4
4
description: wire hive meta options.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Meta Options
8
8
9
9
{{ $frontmatter.description }}
10
10
···
57
57
meta.specialArgs = {
58
58
# pass flake inputs as specialArgs
59
59
inherit inputs;
60
+
};
61
+
}
62
+
```
63
+
64
+
## meta.nodeSpecialArgs
65
+
66
+
Extra `specialArgs` to override `meta.specialArgs` for each node
67
+
68
+
_Type:_ attribute set of attribute set
69
+
70
+
_Default:_ `{ }`
71
+
72
+
_Example:_
73
+
74
+
```nix
75
+
{
76
+
meta.nodeSpecialArgs = {
77
+
extra-property = "some-value";
60
78
};
61
79
}
62
80
```
+1
-1
doc/snippets/getting-started/configuration.nix
+1
-1
doc/snippets/getting-started/configuration.nix
···
1
1
{system, ...}: let
2
2
wire = import (
3
3
# [!code ++]
4
-
builtins.fetchTarball "https://github.com/mrshmllow/wire/archive/refs/heads/trunk.tar.gz" # [!code ++]
4
+
builtins.fetchTarball "https://github.com/forallsys/wire/archive/refs/heads/trunk.tar.gz" # [!code ++]
5
5
); # [!code ++]
6
6
in {
7
7
environment.systemPackages = [
+1
-1
doc/snippets/getting-started/flake-merged.nix
+1
-1
doc/snippets/getting-started/flake-merged.nix
+1
-1
doc/snippets/getting-started/flake.nix
+1
-1
doc/snippets/getting-started/flake.nix
+1
-1
doc/snippets/getting-started/nixos.flake.nix
+1
-1
doc/snippets/getting-started/nixos.flake.nix
+40
doc/snippets/guides/example-action.yml
+40
doc/snippets/guides/example-action.yml
···
1
+
name: Build
2
+
3
+
on:
4
+
push:
5
+
branches: [main]
6
+
7
+
jobs:
8
+
build-partitioned:
9
+
name: Build Partitioned
10
+
runs-on: ubuntu-latest
11
+
permissions: {}
12
+
strategy:
13
+
matrix:
14
+
# Break into 4 partitions
15
+
partition: [1, 2, 3, 4]
16
+
steps:
17
+
- uses: actions/checkout@v6
18
+
with:
19
+
persist-credentials: false
20
+
# This will likely be required if you have multiple architectures
21
+
# in your hive.
22
+
- name: Set up QEMU
23
+
uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130
24
+
- uses: cachix/install-nix-action@4e002c8ec80594ecd40e759629461e26c8abed15
25
+
with:
26
+
nix_path: nixpkgs=channel:nixos-unstable
27
+
extra_nix_config: |
28
+
# Install binary cache as described in the install wire guide
29
+
trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= cache.garnix.io:CTFPyKSLcx5RMJKfLo5EEPUObbA78b0YQ2DTCJXqr9g=
30
+
substituters = https://cache.nixos.org/ https://cache.garnix.io
31
+
32
+
# Again, include additional architectures if you have multiple
33
+
# architectures in your hive
34
+
extra-platforms = aarch64-linux i686-linux
35
+
# Uses wire from your shell (as described in the install wire guide).
36
+
- name: Build partition ${{ matrix.partition }}
37
+
run: nix develop -Lvc wire \
38
+
build \
39
+
--parallel 1 \
40
+
--partition ${{ matrix.partition }}/4
+2
-2
doc/snippets/guides/installation/flake.nix
+2
-2
doc/snippets/guides/installation/flake.nix
···
1
1
{
2
2
inputs = {
3
3
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
4
-
wire.url = "github:mrshmllow/wire/stable";
4
+
wire.url = "github:forallsys/wire/stable";
5
5
6
6
# alternatively, you can use a tag instead:
7
-
# wire.url = "github:mrshmllow/wire/v1.0.0-beta.0";
7
+
# wire.url = "github:forallsys/wire/v1.1.1";
8
8
9
9
systems.url = "github:nix-systems/default";
10
10
};
+3
doc/snippets/tutorial/cache.conf
+3
doc/snippets/tutorial/cache.conf
+12
doc/snippets/tutorial/cache.nix
+12
doc/snippets/tutorial/cache.nix
+2
-18
doc/tutorial/overview.md
+2
-18
doc/tutorial/overview.md
···
4
4
description: In this tutorial we will create and deploy a wire Hive.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# wire Tutorial Overview
8
8
9
9
wire is a tool to deploy NixOS systems. Its usage is inspired by [colmena](https://colmena.cli.rs/). In many places it's configuration attempts to remain a superset[^1] of colmena, however it is **not** a fork.
10
10
11
11
[^1]: A lot of your colmena module options will continue to work with wire, but wire has additional ergonomic changes you can take advantage of.
12
-
13
-
::: warning
14
-
wire is alpha software, please use at your own risk.
15
-
:::
16
12
17
13
---
18
14
···
28
24
29
25
</div>
30
26
31
-
## Why wire?
32
-
33
-
### Features
27
+
## What features does wire have?
34
28
35
29
| Features | wire | Colmena |
36
30
| ------------------------------------------------------------- | ------------------ | ------------------ |
···
50
44
[^3]: See https://github.com/zhaofengli/colmena/issues/120
51
45
52
46
[^4]: wire lacks an equivalent to `colmena exec`.
53
-
54
-
### Speed
55
-
56
-
wire is about >2x faster than colmena deploying [identical large
57
-
hives](https://github.com/mrshmllow/wire/blob/trunk/bench/run.nix).
58
-
59
-
| Command | Mean [s] | Min [s] | Max [s] | Relative |
60
-
| :--------------- | -------: | ------: | ------: | -------: |
61
-
| `wire@HEAD` | 185.075 | 185.075 | 185.075 | 1.00 |
62
-
| `colmena@pinned` | 343.075 | 343.075 | 343.075 | 1.85 |
+1
-1
doc/tutorial/part-one/basic-hive.md
+1
-1
doc/tutorial/part-one/basic-hive.md
+7
-2
doc/tutorial/part-one/nix-setup.md
+7
-2
doc/tutorial/part-one/nix-setup.md
···
4
4
description: Installing npins, nix, and enabling the binary cache.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Nix Setup
8
8
9
9
{{ $frontmatter.description }}
10
10
···
32
32
cache](https://wiki.nixos.org/wiki/Binary_Cache).
33
33
34
34
You must enable the [garnix binary cache](https://garnix.io/docs/caching) or you
35
-
will be compiling everything from source.
35
+
will be compiling everything from source:
36
+
37
+
::: code-group
38
+
<<< @/snippets/tutorial/cache.conf [nix.conf]
39
+
<<< @/snippets/tutorial/cache.nix [configuration.nix]
40
+
:::
+5
-5
doc/tutorial/part-one/repo-setup.md
+5
-5
doc/tutorial/part-one/repo-setup.md
···
4
4
description: Adding npins sources and a nix development shell.
5
5
---
6
6
7
-
# {{ $frontmatter.title }}
7
+
# Preparing Repo & Shell
8
8
9
9
{{ $frontmatter.description }}
10
10
···
39
39
40
40
## Adding wire as a dependency
41
41
42
-
We can now need to tell `npins` to use `mrshmllow/wire` as a dependency.
42
+
We can now need to tell `npins` to use `forallsys/wire` as a dependency.
43
43
44
44
```sh
45
-
[nix-shell]$ npins add github mrshmllow wire --branch stable
45
+
[nix-shell]$ npins add github forallsys wire --branch stable
46
46
[INFO ] Adding 'wire' โฆ
47
-
repository: https://github.com/mrshmllow/wire.git
47
+
repository: https://github.com/forallsys/wire.git
48
48
pre_releases: false
49
49
submodules: false
50
50
version: v0.4.0
···
68
68
frozen: false
69
69
70
70
wire: (git release tag)
71
-
repository: https://github.com/mrshmllow/wire.git
71
+
repository: https://github.com/forallsys/wire.git
72
72
pre_releases: false
73
73
submodules: false
74
74
version: v0.4.0
+1
-1
doc/tutorial/part-one/vm-setup.md
+1
-1
doc/tutorial/part-one/vm-setup.md
+1
-1
doc/tutorial/part-two/basic-keys.md
+1
-1
doc/tutorial/part-two/basic-keys.md
+1
-1
doc/tutorial/part-two/encryption.md
+1
-1
doc/tutorial/part-two/encryption.md
+3
-3
flake.nix
+3
-3
flake.nix
···
37
37
./nix/utils.nix # utility functions
38
38
./nix/shells.nix
39
39
./nix/tests.nix
40
-
./wire/cli
41
-
./wire/agent
40
+
./crates/cli
41
+
./crates/key_agent
42
42
./doc
43
43
./tests/nix
44
44
./runtime
···
86
86
# docs only
87
87
alejandra.enable = true;
88
88
rustfmt.enable = true;
89
-
just.enable = true;
90
89
prettier.enable = true;
91
90
protolint.enable = true;
92
91
taplo.enable = true;
92
+
ruff-format.enable = true;
93
93
};
94
94
settings.formatter = {
95
95
nixfmt.excludes = [ "doc/snippets/*.nix" ];
+22
-2
garnix.yaml
+22
-2
garnix.yaml
···
1
1
builds:
2
-
exclude: ["checks.*.*"]
3
-
branch: trunk
2
+
- exclude: []
3
+
include:
4
+
- packages.x86_64-linux.docs
5
+
- packages.x86_64-linux.docs-unstable
6
+
- packages.*.wire
7
+
- packages.*.wire-small
8
+
branch: trunk
9
+
- exclude: []
10
+
include:
11
+
- packages.x86_64-linux.docs
12
+
- packages.x86_64-linux.docs-unstable
13
+
- packages.*.wire
14
+
- packages.*.wire-small
15
+
branch: stable
16
+
# used to run garnix on an arbitrary commit in a throwaway branch
17
+
- exclude: []
18
+
include:
19
+
- packages.x86_64-linux.docs
20
+
- packages.x86_64-linux.docs-unstable
21
+
- packages.*.wire
22
+
- packages.*.wire-small
23
+
branch: arbitrary
-7
justfile
-7
justfile
+20
nix/hooks.nix
+20
nix/hooks.nix
···
4
4
toolchain,
5
5
config,
6
6
lib,
7
+
pkgs,
7
8
...
8
9
}:
9
10
{
···
15
16
enable = true;
16
17
settings.edit = true;
17
18
};
19
+
zizmor.enable = true;
18
20
clippy = {
19
21
enable = true;
20
22
settings.extraArgs = "--tests";
···
22
24
inherit (toolchain) cargo clippy;
23
25
};
24
26
};
27
+
ruff.enable = true;
25
28
cargo-check = {
26
29
enable = true;
27
30
package = toolchain.cargo;
···
30
33
enable = true;
31
34
name = "nix fmt";
32
35
entry = "${lib.getExe config.formatter} --no-cache";
36
+
};
37
+
ty = {
38
+
enable = true;
39
+
name = "ty check";
40
+
files = "\\.py$";
41
+
entry = lib.getExe (
42
+
pkgs.writeShellScriptBin "ty-check" ''
43
+
cd tests/nix
44
+
${lib.getExe pkgs.uv} run ty check
45
+
''
46
+
);
47
+
};
48
+
machete = {
49
+
enable = true;
50
+
name = "cargo-machete";
51
+
files = "\\.(rs|toml)$";
52
+
entry = lib.getExe pkgs.cargo-machete;
33
53
};
34
54
typos = {
35
55
enable = true;
+1
-1
nix/shells.nix
+1
-1
nix/shells.nix
+1
-1
nix/tests.nix
+1
-1
nix/tests.nix
+1
-1
nix/utils.nix
+1
-1
nix/utils.nix
+2
-1
runtime/evaluate.nix
+2
-1
runtime/evaluate.nix
+2
-69
runtime/module/config.nix
+2
-69
runtime/module/config.nix
···
22
22
}
23
23
) config.deployment.keys;
24
24
25
-
system.activationScripts.setup-wire-rollback.text = ''
26
-
mkdir -p /var/lib/wire-rollback
27
-
chmod 700 /var/lib/wire-rollback
28
-
'';
29
-
30
-
services = {
31
-
wire-rollback = {
32
-
enable = config.deployment.rollback;
33
-
description = "Rolls back the NixOS profile if `/var/lib/wire-rollback/heartbeat` is not created in 30
34
-
seconds after this service starts.";
35
-
documentation = [
36
-
"https://wire.althaea.zone/guides/rollback"
37
-
];
38
-
path = [
39
-
pkgs.coreutils
40
-
];
41
-
wantedBy = [ "multi-user.target" ];
42
-
script = ''
43
-
set -euo pipefail
44
-
45
-
goal=$(<"/var/lib/wire-rollback/goal")
46
-
47
-
case $goal in
48
-
"check" | "switch" | "boot" | "test" | "dry-activate")
49
-
echo "<5>using goal $goal"
50
-
;;
51
-
*)
52
-
echo "<3>'$goal' is not a valid goal."
53
-
exit 1
54
-
;;
55
-
esac
56
-
57
-
sleep 30
58
-
59
-
if [ -f "/var/lib/wire-rollback/heartbeat" ]; then
60
-
exit 0
61
-
fi
62
-
63
-
echo "<1>/var/lib/wire-rollback/heartbeat does not exist, rolling back system"
64
-
65
-
# set current system
66
-
nix-env --rollback --profile /nix/var/nix/profiles/system
67
-
# get the path to the system we are now rolling back to
68
-
system=$(readlink -f /nix/var/nix/profiles/system)
69
-
70
-
echo "<5>rolling back to $system"
71
-
72
-
# switch to the system using goal
73
-
"$system/bin/switch-to-configuration $goal"
74
-
'';
75
-
unitConfig = {
76
-
ConditionPathExists = [
77
-
"/var/lib/wire-rollback/goal"
78
-
"!/var/lib/wire-rollback/heartbeat"
79
-
];
80
-
};
81
-
serviceConfig = {
82
-
Type = "oneshot";
83
-
Restart = "no";
84
-
StateDirectory = "wire-rollback";
85
-
NotifyAccess = "all";
86
-
RemainAfterExit = "yes";
87
-
88
-
ExecStopPost = "${pkgs.coreutils}/bin/rm -f /var/lib/wire-rollback/goal";
89
-
};
90
-
};
91
-
}
92
-
// (lib.mapAttrs' (
25
+
services = lib.mapAttrs' (
93
26
_name: value:
94
27
lib.nameValuePair "${value.name}-key" {
95
28
description = "Service that requires ${value.path}";
···
122
55
RemainAfterExit = "yes";
123
56
};
124
57
}
125
-
) config.deployment.keys);
58
+
) config.deployment.keys;
126
59
};
127
60
128
61
deployment = {
-6
runtime/module/options.nix
-6
runtime/module/options.nix
···
50
50
default = { };
51
51
};
52
52
53
-
rollback = lib.mkOption {
54
-
type = types.bool;
55
-
default = true;
56
-
description = "Attempt to rollback this node if it cannot be contacted after activation.";
57
-
};
58
-
59
53
buildOnTarget = lib.mkOption {
60
54
type = types.bool;
61
55
default = false;
+1
tests/nix/.python-version
+1
tests/nix/.python-version
···
1
+
3.13
+9
-2
tests/nix/default.nix
+9
-2
tests/nix/default.nix
···
23
23
lazyAttrsOf
24
24
;
25
25
cfg = config.wire.testing;
26
+
27
+
stripTyping =
28
+
value:
29
+
let
30
+
split = builtins.split "(from typing import TYPE_CHECKING|# typing-end)" value;
31
+
in
32
+
(builtins.elemAt split 0) + (builtins.elemAt split 4);
26
33
in
27
34
{
28
35
imports = [
···
30
37
./suite/test_local_deploy
31
38
./suite/test_keys
32
39
./suite/test_stdin
33
-
./suite/test_rollback
34
40
];
35
41
options.wire.testing = mkOption {
36
42
type = attrsOf (
···
45
51
type = lines;
46
52
default = '''';
47
53
description = "test script for runNixOSTest";
54
+
apply = stripTyping;
48
55
};
49
56
testDir = mkOption {
50
57
default = "${self}/tests/nix/suite/${name}";
···
164
171
165
172
TEST_DIR="${injectedFlakeDir}/${path}"
166
173
167
-
${builtins.readFile ./tools.py}
174
+
${stripTyping (builtins.readFile ./tools/__init__.py)}
168
175
''
169
176
+ lib.concatStringsSep "\n" (mapAttrsToList (_: value: value._wire.testScript) value.nodes)
170
177
+ opts.testScript;
+18
tests/nix/pyproject.toml
+18
tests/nix/pyproject.toml
···
1
+
[project]
2
+
name = "wire-vm-tests"
3
+
version = "0.0.0"
4
+
requires-python = ">=3.13"
5
+
dependencies = [
6
+
"colorama>=0.4.6",
7
+
"ipython>=9.8.0",
8
+
"junit-xml>=1.9",
9
+
"nixos-test-driver",
10
+
"ptpython>=3.0.32",
11
+
"remote-pdb>=2.1.0",
12
+
]
13
+
14
+
[tool.uv.sources]
15
+
nixos-test-driver = { git = "https://github.com/NixOS/nixpkgs", subdirectory = "nixos/lib/test-driver/src", branch = "nixos-25.11" }
16
+
17
+
[dependency-groups]
18
+
dev = ["ty>=0.0.4"]
+1
-82
tests/nix/suite/test_keys/default.nix
+1
-82
tests/nix/suite/test_keys/default.nix
···
10
10
nodes.receiver = {
11
11
_wire.receiver = true;
12
12
};
13
-
testScript = ''
14
-
deployer_so = collect_store_objects(deployer)
15
-
receiver_so = collect_store_objects(receiver)
16
-
17
-
# build receiver with no keys
18
-
deployer.succeed(f"wire apply --no-progress --on receiver --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2")
19
-
20
-
receiver.wait_for_unit("sshd.service")
21
-
22
-
# --no-keys should never push a key
23
-
receiver.fail("test -f /run/keys/source_string_name")
24
-
deployer.fail("test -f /run/keys/source_string_name")
25
-
26
-
# key services are created
27
-
receiver.succeed("systemctl cat source_string_name-key.service")
28
-
29
-
_, is_failed = receiver.execute("systemctl is-failed source_string_name-key.service")
30
-
assert is_failed == "inactive\n", f"source_string_name-key.service must be inactive before key exists ({is_failed})"
31
-
32
-
def test_keys(target, target_object, non_interactive):
33
-
if non_interactive:
34
-
deployer.succeed(f"wire apply keys --on {target} --no-progress --path {TEST_DIR}/hive.nix --non-interactive --ssh-accept-host -vvv >&2")
35
-
else:
36
-
deployer.succeed(f"wire apply keys --on {target} --no-progress --path {TEST_DIR}/hive.nix --ssh-accept-host -vvv >&2")
37
-
38
-
keys = [
39
-
("/run/keys/source_string_name", "hello_world_source", "root root 600", "source_string_name"),
40
-
("/etc/keys/file", "hello_world_file", "root root 644", "file"),
41
-
("/home/owner/some/deep/path/command", "hello_world_command", "owner owner 644", "command"),
42
-
("/run/keys/environment", "string_from_environment", "root root 600", "environment"),
43
-
]
44
-
45
-
for path, value, permissions, name in keys:
46
-
# test existence & value
47
-
source_string = target_object.succeed(f"cat {path}")
48
-
assert value in source_string, f"{path} has correct contents ({target})"
49
-
50
-
stat = target_object.succeed(f"stat -c '%U %G %a' {path}").rstrip()
51
-
assert permissions == stat, f"{path} has correct permissions ({target})"
52
-
53
-
def perform_routine(target, target_object, non_interactive):
54
-
test_keys(target, target_object, non_interactive)
55
-
56
-
# only check systemd units on receiver since deployer apply's are one time only
57
-
if target == "receiver":
58
-
target_object.succeed("systemctl start source_string_name-key.path")
59
-
target_object.succeed("systemctl start command-key.path")
60
-
target_object.wait_for_unit("source_string_name-key.service")
61
-
target_object.wait_for_unit("command-key.service")
62
-
63
-
# Mess with the keys to make sure that every push refreshes the permissions
64
-
target_object.succeed("echo 'incorrect_value' > /run/keys/source_string")
65
-
target_object.succeed("chown 600 /etc/keys/file")
66
-
# Test having a key that doesn't exist mixed with keys that do
67
-
target_object.succeed("rm /home/owner/some/deep/path/command")
68
-
69
-
if target == "receiver":
70
-
_, is_failed = target_object.execute("systemctl is-active command-key.service")
71
-
assert is_failed == "failed\n", f"command-key.service is failed after deletion ({is_failed})"
72
-
73
-
# Test keys twice to ensure the operation is idempotent,
74
-
# especially around directory creation.
75
-
test_keys(target, target_object, non_interactive)
76
-
77
-
perform_routine("receiver", receiver, True)
78
-
perform_routine("deployer", deployer, True)
79
-
perform_routine("receiver", receiver, False)
80
-
perform_routine("deployer", deployer, False)
81
-
82
-
new_deployer_store_objects = collect_store_objects(deployer).difference(deployer_so)
83
-
new_receiver_store_objects = collect_store_objects(receiver).difference(receiver_so)
84
-
85
-
# no one should have any keys introduced by the operation
86
-
for node, objects in [
87
-
(deployer, new_deployer_store_objects),
88
-
(receiver, new_receiver_store_objects),
89
-
]:
90
-
assert_store_not_poisoned(node, "hello_world_source", objects)
91
-
assert_store_not_poisoned(node, "hello_world_file", objects)
92
-
assert_store_not_poisoned(node, "hello_world_command", objects)
93
-
assert_store_not_poisoned(node, "string_from_environment", objects)
94
-
'';
13
+
testScript = builtins.readFile ./script.py;
95
14
};
96
15
}
+123
tests/nix/suite/test_keys/script.py
+123
tests/nix/suite/test_keys/script.py
···
1
+
# SPDX-License-Identifier: AGPL-3.0-or-later
2
+
# Copyright 2024-2025 wire Contributors
3
+
4
+
from typing import TYPE_CHECKING
5
+
6
+
if TYPE_CHECKING:
7
+
from test_driver.machine import Machine
8
+
from tools import collect_store_objects, assert_store_not_poisoned
9
+
10
+
deployer: Machine = None # type: ignore[invalid-assignment]
11
+
receiver: Machine = None # type: ignore[invalid-assignment]
12
+
TEST_DIR = ""
13
+
14
+
# typing-end
15
+
16
+
deployer_so = collect_store_objects(deployer)
17
+
receiver_so = collect_store_objects(receiver)
18
+
19
+
# build receiver with no keys
20
+
deployer.succeed(
21
+
f"wire apply --no-progress --on receiver --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2"
22
+
)
23
+
24
+
receiver.wait_for_unit("sshd.service")
25
+
26
+
# --no-keys should never push a key
27
+
receiver.fail("test -f /run/keys/source_string_name")
28
+
deployer.fail("test -f /run/keys/source_string_name")
29
+
30
+
# key services are created
31
+
receiver.succeed("systemctl cat source_string_name-key.service")
32
+
33
+
_, is_failed = receiver.execute("systemctl is-failed source_string_name-key.service")
34
+
assert is_failed == "inactive\n", (
35
+
f"source_string_name-key.service must be inactive before key exists ({is_failed})"
36
+
)
37
+
38
+
39
+
def test_keys(target, target_object, non_interactive):
40
+
if non_interactive:
41
+
deployer.succeed(
42
+
f"wire apply keys --on {target} --no-progress --path {TEST_DIR}/hive.nix --non-interactive --ssh-accept-host -vvv >&2"
43
+
)
44
+
else:
45
+
deployer.succeed(
46
+
f"wire apply keys --on {target} --no-progress --path {TEST_DIR}/hive.nix --ssh-accept-host -vvv >&2"
47
+
)
48
+
49
+
keys = [
50
+
(
51
+
"/run/keys/source_string_name",
52
+
"hello_world_source",
53
+
"root root 600",
54
+
"source_string_name",
55
+
),
56
+
("/etc/keys/file", "hello_world_file", "root root 644", "file"),
57
+
(
58
+
"/home/owner/some/deep/path/command",
59
+
"hello_world_command",
60
+
"owner owner 644",
61
+
"command",
62
+
),
63
+
(
64
+
"/run/keys/environment",
65
+
"string_from_environment",
66
+
"root root 600",
67
+
"environment",
68
+
),
69
+
]
70
+
71
+
for path, value, permissions, name in keys:
72
+
# test existence & value
73
+
source_string = target_object.succeed(f"cat {path}")
74
+
assert value in source_string, f"{path} has correct contents ({target})"
75
+
76
+
stat = target_object.succeed(f"stat -c '%U %G %a' {path}").rstrip()
77
+
assert permissions == stat, f"{path} has correct permissions ({target})"
78
+
79
+
80
+
def perform_routine(target, target_object, non_interactive):
81
+
test_keys(target, target_object, non_interactive)
82
+
83
+
# only check systemd units on receiver since deployer apply's are one time only
84
+
if target == "receiver":
85
+
target_object.succeed("systemctl start source_string_name-key.path")
86
+
target_object.succeed("systemctl start command-key.path")
87
+
target_object.wait_for_unit("source_string_name-key.service")
88
+
target_object.wait_for_unit("command-key.service")
89
+
90
+
# Mess with the keys to make sure that every push refreshes the permissions
91
+
target_object.succeed("echo 'incorrect_value' > /run/keys/source_string")
92
+
target_object.succeed("chown 600 /etc/keys/file")
93
+
# Test having a key that doesn't exist mixed with keys that do
94
+
target_object.succeed("rm /home/owner/some/deep/path/command")
95
+
96
+
if target == "receiver":
97
+
_, is_failed = target_object.execute("systemctl is-active command-key.service")
98
+
assert is_failed == "failed\n", (
99
+
f"command-key.service is failed after deletion ({is_failed})"
100
+
)
101
+
102
+
# Test keys twice to ensure the operation is idempotent,
103
+
# especially around directory creation.
104
+
test_keys(target, target_object, non_interactive)
105
+
106
+
107
+
perform_routine("receiver", receiver, True)
108
+
perform_routine("deployer", deployer, True)
109
+
perform_routine("receiver", receiver, False)
110
+
perform_routine("deployer", deployer, False)
111
+
112
+
new_deployer_store_objects = collect_store_objects(deployer).difference(deployer_so)
113
+
new_receiver_store_objects = collect_store_objects(receiver).difference(receiver_so)
114
+
115
+
# no one should have any keys introduced by the operation
116
+
for node, objects in [
117
+
(deployer, new_deployer_store_objects),
118
+
(receiver, new_receiver_store_objects),
119
+
]:
120
+
assert_store_not_poisoned(node, "hello_world_source", objects)
121
+
assert_store_not_poisoned(node, "hello_world_file", objects)
122
+
assert_store_not_poisoned(node, "hello_world_command", objects)
123
+
assert_store_not_poisoned(node, "string_from_environment", objects)
+1
-4
tests/nix/suite/test_local_deploy/default.nix
+1
-4
tests/nix/suite/test_local_deploy/default.nix
···
7
7
_wire.deployer = true;
8
8
_wire.receiver = true;
9
9
};
10
-
testScript = ''
11
-
deployer.succeed(f"wire apply --on deployer --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2")
12
-
deployer.succeed("test -f /etc/a")
13
-
'';
10
+
testScript = builtins.readFile ./script.py;
14
11
};
15
12
}
+17
tests/nix/suite/test_local_deploy/script.py
+17
tests/nix/suite/test_local_deploy/script.py
···
1
+
# SPDX-License-Identifier: AGPL-3.0-or-later
2
+
# Copyright 2024-2025 wire Contributors
3
+
4
+
from typing import TYPE_CHECKING
5
+
6
+
if TYPE_CHECKING:
7
+
from test_driver.machine import Machine
8
+
9
+
deployer: Machine = None # type: ignore[invalid-assignment]
10
+
TEST_DIR = ""
11
+
12
+
# typing-end
13
+
14
+
deployer.succeed(
15
+
f"wire apply --on deployer --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2"
16
+
)
17
+
deployer.succeed("test -f /etc/a")
+1
-36
tests/nix/suite/test_remote_deploy/default.nix
+1
-36
tests/nix/suite/test_remote_deploy/default.nix
···
9
9
nodes.receiver = {
10
10
_wire.receiver = true;
11
11
};
12
-
testScript = ''
13
-
with subtest("Test unreachable hosts"):
14
-
deployer.fail(f"wire apply --on receiver-unreachable --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2")
15
-
16
-
with subtest("Check basic apply: Interactive"):
17
-
deployer.succeed(f"wire apply --on receiver --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2")
18
-
19
-
identity = receiver.succeed("cat /etc/identity")
20
-
assert identity == "first", "Identity of first apply wasn't as expected"
21
-
22
-
with subtest("Check basic apply: NonInteractive"):
23
-
deployer.succeed(f"wire apply --on receiver-third --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host --non-interactive -vvv >&2")
24
-
25
-
identity = receiver.succeed("cat /etc/identity")
26
-
assert identity == "third", "Identity of non-interactive apply wasn't as expected"
27
-
28
-
with subtest("Check boot apply"):
29
-
first_system = receiver.succeed("readlink -f /run/current-system")
30
-
31
-
deployer.succeed(f"wire apply boot --on receiver-second --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2")
32
-
33
-
_first_system = receiver.succeed("readlink -f /run/current-system")
34
-
assert first_system == _first_system, "apply boot without --reboot changed /run/current-system"
35
-
36
-
# with subtest("Check /etc/identity after reboot"):
37
-
# receiver.reboot()
38
-
#
39
-
# identity = receiver.succeed("cat /etc/identity")
40
-
# assert identity == "second", "Identity didn't change after second apply"
41
-
42
-
# with subtest("Check --reboot"):
43
-
# deployer.succeed(f"wire apply boot --on receiver-third --no-progress --path {TEST_DIR}/hive.nix --reboot --no-keys -vvv >&2")
44
-
#
45
-
# identity = receiver.succeed("cat /etc/identity")
46
-
# assert identity == "third", "Identity didn't change after third apply"
47
-
'';
12
+
testScript = builtins.readFile ./script.py;
48
13
};
49
14
}
+25
-9
tests/nix/suite/test_remote_deploy/hive.nix
+25
-9
tests/nix/suite/test_remote_deploy/hive.nix
···
5
5
inherit (import ../utils.nix { testName = "test_keys-@IDENT@"; }) makeHive mkHiveNode;
6
6
in
7
7
makeHive {
8
-
meta.nixpkgs = import <nixpkgs> { localSystem = "x86_64-linux"; };
8
+
meta = {
9
+
nixpkgs = import <nixpkgs> { localSystem = "x86_64-linux"; };
10
+
11
+
specialArgs = {
12
+
message = "second";
13
+
};
14
+
15
+
nodeSpecialArgs = {
16
+
receiver-third.message = "third";
17
+
};
18
+
};
9
19
10
20
receiver = mkHiveNode { hostname = "receiver"; } {
11
21
environment.etc."identity".text = "first";
···
20
30
];
21
31
};
22
32
23
-
receiver-second = mkHiveNode { hostname = "receiver"; } {
24
-
environment.etc."identity".text = "second";
25
-
deployment.target.host = "receiver";
26
-
};
33
+
receiver-second = mkHiveNode { hostname = "receiver"; } (
34
+
{ message, ... }:
35
+
{
36
+
environment.etc."identity".text = message;
37
+
deployment.target.host = "receiver";
38
+
}
39
+
);
27
40
28
-
receiver-third = mkHiveNode { hostname = "receiver"; } {
29
-
environment.etc."identity".text = "third";
30
-
deployment.target.host = "receiver";
31
-
};
41
+
receiver-third = mkHiveNode { hostname = "receiver"; } (
42
+
{ message, ... }:
43
+
{
44
+
environment.etc."identity".text = message;
45
+
deployment.target.host = "receiver";
46
+
}
47
+
);
32
48
33
49
receiver-unreachable = mkHiveNode { hostname = "receiver"; } {
34
50
# test node pinging
+63
tests/nix/suite/test_remote_deploy/script.py
+63
tests/nix/suite/test_remote_deploy/script.py
···
1
+
# SPDX-License-Identifier: AGPL-3.0-or-later
2
+
# Copyright 2024-2025 wire Contributors
3
+
4
+
from typing import TYPE_CHECKING
5
+
from typing import Callable, ContextManager
6
+
7
+
if TYPE_CHECKING:
8
+
from test_driver.machine import Machine
9
+
10
+
deployer: Machine = None # type: ignore[invalid-assignment]
11
+
receiver: Machine = None # type: ignore[invalid-assignment]
12
+
13
+
TEST_DIR = ""
14
+
15
+
# https://github.com/NixOS/nixpkgs/blob/d10d9933b1c206f9b2950e5e1d68268c5ed0a3c7/nixos/lib/test-script-prepend.py#L43
16
+
subtest: Callable[[str], ContextManager[None]] = None # type: ignore[invalid-assignment]
17
+
18
+
# typing-end
19
+
20
+
with subtest("Test unreachable hosts"):
21
+
deployer.fail(
22
+
f"wire apply --on receiver-unreachable --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2"
23
+
)
24
+
25
+
with subtest("Check basic apply: Interactive"):
26
+
deployer.succeed(
27
+
f"wire apply --on receiver --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2"
28
+
)
29
+
30
+
identity = receiver.succeed("cat /etc/identity")
31
+
assert identity == "first", "Identity of first apply wasn't as expected"
32
+
33
+
with subtest("Check basic apply: NonInteractive"):
34
+
deployer.succeed(
35
+
f"wire apply --on receiver-third --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host --non-interactive -vvv >&2"
36
+
)
37
+
38
+
identity = receiver.succeed("cat /etc/identity")
39
+
assert identity == "third", "Identity of non-interactive apply wasn't as expected"
40
+
41
+
with subtest("Check boot apply"):
42
+
first_system = receiver.succeed("readlink -f /run/current-system")
43
+
44
+
deployer.succeed(
45
+
f"wire apply boot --on receiver-second --no-progress --path {TEST_DIR}/hive.nix --no-keys --ssh-accept-host -vvv >&2"
46
+
)
47
+
48
+
_first_system = receiver.succeed("readlink -f /run/current-system")
49
+
assert first_system == _first_system, (
50
+
"apply boot without --reboot changed /run/current-system"
51
+
)
52
+
53
+
# with subtest("Check /etc/identity after reboot"):
54
+
# receiver.reboot()
55
+
#
56
+
# identity = receiver.succeed("cat /etc/identity")
57
+
# assert identity == "second", "Identity didn't change after second apply"
58
+
59
+
# with subtest("Check --reboot"):
60
+
# deployer.succeed(f"wire apply boot --on receiver-third --no-progress --path {TEST_DIR}/hive.nix --reboot --no-keys -vvv >&2")
61
+
#
62
+
# identity = receiver.succeed("cat /etc/identity")
63
+
# assert identity == "third", "Identity didn't change after third apply"
-20
tests/nix/suite/test_rollback/default.nix
-20
tests/nix/suite/test_rollback/default.nix
···
1
-
# SPDX-License-Identifier: AGPL-3.0-or-later
2
-
# Copyright 2024-2025 wire Contributors
3
-
4
-
{
5
-
wire.testing.test_remote_deploy = {
6
-
nodes.deployer = {
7
-
_wire.deployer = true;
8
-
};
9
-
nodes.receiver = {
10
-
_wire.receiver = true;
11
-
};
12
-
testScript = ''
13
-
with subtest("Deploy broken config"):
14
-
deployer.fail(f"wire apply --on receiver --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2")
15
-
16
-
with subtest("Configuration must revert"):
17
-
receiver.wait_for_unit("sshd.service")
18
-
'';
19
-
};
20
-
}
-15
tests/nix/suite/test_rollback/hive.nix
-15
tests/nix/suite/test_rollback/hive.nix
···
1
-
# SPDX-License-Identifier: AGPL-3.0-or-later
2
-
# Copyright 2024-2025 wire Contributors
3
-
4
-
let
5
-
inherit (import ../utils.nix { testName = "test_rollback-@IDENT@"; }) makeHive mkHiveNode;
6
-
in
7
-
makeHive {
8
-
meta.nixpkgs = import <nixpkgs> { localSystem = "x86_64-linux"; };
9
-
10
-
receiver = mkHiveNode { hostname = "receiver"; } {
11
-
environment.etc."identity".text = "first";
12
-
13
-
services.openssh.enable = false;
14
-
};
15
-
}
+1
-4
tests/nix/suite/test_stdin/default.nix
+1
-4
tests/nix/suite/test_stdin/default.nix
···
7
7
_wire.deployer = true;
8
8
_wire.receiver = true;
9
9
};
10
-
testScript = ''
11
-
deployer.succeed(f"echo @tag | wire apply --on deployer --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2")
12
-
deployer.succeed("test -f /etc/a")
13
-
'';
10
+
testScript = builtins.readFile ./script.py;
14
11
};
15
12
}
+17
tests/nix/suite/test_stdin/script.py
+17
tests/nix/suite/test_stdin/script.py
···
1
+
# SPDX-License-Identifier: AGPL-3.0-or-later
2
+
# Copyright 2024-2025 wire Contributors
3
+
4
+
from typing import TYPE_CHECKING
5
+
6
+
if TYPE_CHECKING:
7
+
from test_driver.machine import Machine
8
+
9
+
deployer: Machine = None # type: ignore[invalid-assignment]
10
+
TEST_DIR = ""
11
+
12
+
# typing-end
13
+
14
+
deployer.succeed(
15
+
f"echo @tag | wire apply --on deployer --no-progress --path {TEST_DIR}/hive.nix --no-keys -vvv >&2"
16
+
)
17
+
deployer.succeed("test -f /etc/a")
+20
tests/nix/tools/__init__.py
+20
tests/nix/tools/__init__.py
···
1
+
# SPDX-License-Identifier: AGPL-3.0-or-later
2
+
# Copyright 2024-2025 wire Contributors
3
+
4
+
from typing import TYPE_CHECKING
5
+
6
+
if TYPE_CHECKING:
7
+
from test_driver.machine import Machine
8
+
9
+
# typing-end
10
+
11
+
12
+
def collect_store_objects(machine: Machine) -> set[str]:
13
+
return set(machine.succeed("ls /nix/store").strip().split("\n"))
14
+
15
+
16
+
def assert_store_not_poisoned(machine: Machine, poison: str, objects: set[str]):
17
+
paths = list(map(lambda n: f"/nix/store/{n}", objects))
18
+
19
+
machine.succeed("which rg")
20
+
machine.fail(f"rg '{poison}' {' '.join(paths)}")
-13
tests/nix/tools.py
-13
tests/nix/tools.py
···
1
-
# SPDX-License-Identifier: AGPL-3.0-or-later
2
-
# Copyright 2024-2025 wire Contributors
3
-
4
-
5
-
def collect_store_objects(machine: Machine) -> set[str]:
6
-
return set(machine.succeed("ls /nix/store").strip().split("\n"))
7
-
8
-
9
-
def assert_store_not_poisoned(machine: Machine, poison: str, objects: set[str]):
10
-
paths = list(map(lambda n: f"/nix/store/{n}", objects))
11
-
12
-
machine.succeed("which rg")
13
-
machine.fail(f"rg '{poison}' {" ".join(paths)}")
+303
tests/nix/uv.lock
+303
tests/nix/uv.lock
···
1
+
version = 1
2
+
revision = 3
3
+
requires-python = ">=3.13"
4
+
5
+
[[package]]
6
+
name = "appdirs"
7
+
version = "1.4.4"
8
+
source = { registry = "https://pypi.org/simple" }
9
+
sdist = { url = "https://files.pythonhosted.org/packages/d7/d8/05696357e0311f5b5c316d7b95f46c669dd9c15aaeecbb48c7d0aeb88c40/appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41", size = 13470, upload-time = "2020-05-11T07:59:51.037Z" }
10
+
wheels = [
11
+
{ url = "https://files.pythonhosted.org/packages/3b/00/2344469e2084fb287c2e0b57b72910309874c3245463acd6cf5e3db69324/appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128", size = 9566, upload-time = "2020-05-11T07:59:49.499Z" },
12
+
]
13
+
14
+
[[package]]
15
+
name = "asttokens"
16
+
version = "3.0.1"
17
+
source = { registry = "https://pypi.org/simple" }
18
+
sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
19
+
wheels = [
20
+
{ url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
21
+
]
22
+
23
+
[[package]]
24
+
name = "colorama"
25
+
version = "0.4.6"
26
+
source = { registry = "https://pypi.org/simple" }
27
+
sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
28
+
wheels = [
29
+
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
30
+
]
31
+
32
+
[[package]]
33
+
name = "decorator"
34
+
version = "5.2.1"
35
+
source = { registry = "https://pypi.org/simple" }
36
+
sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
37
+
wheels = [
38
+
{ url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
39
+
]
40
+
41
+
[[package]]
42
+
name = "executing"
43
+
version = "2.2.1"
44
+
source = { registry = "https://pypi.org/simple" }
45
+
sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
46
+
wheels = [
47
+
{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
48
+
]
49
+
50
+
[[package]]
51
+
name = "ipython"
52
+
version = "9.8.0"
53
+
source = { registry = "https://pypi.org/simple" }
54
+
dependencies = [
55
+
{ name = "colorama", marker = "sys_platform == 'win32'" },
56
+
{ name = "decorator" },
57
+
{ name = "ipython-pygments-lexers" },
58
+
{ name = "jedi" },
59
+
{ name = "matplotlib-inline" },
60
+
{ name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
61
+
{ name = "prompt-toolkit" },
62
+
{ name = "pygments" },
63
+
{ name = "stack-data" },
64
+
{ name = "traitlets" },
65
+
]
66
+
sdist = { url = "https://files.pythonhosted.org/packages/12/51/a703c030f4928646d390b4971af4938a1b10c9dfce694f0d99a0bb073cb2/ipython-9.8.0.tar.gz", hash = "sha256:8e4ce129a627eb9dd221c41b1d2cdaed4ef7c9da8c17c63f6f578fe231141f83", size = 4424940, upload-time = "2025-12-03T10:18:24.353Z" }
67
+
wheels = [
68
+
{ url = "https://files.pythonhosted.org/packages/f1/df/8ee1c5dd1e3308b5d5b2f2dfea323bb2f3827da8d654abb6642051199049/ipython-9.8.0-py3-none-any.whl", hash = "sha256:ebe6d1d58d7d988fbf23ff8ff6d8e1622cfdb194daf4b7b73b792c4ec3b85385", size = 621374, upload-time = "2025-12-03T10:18:22.335Z" },
69
+
]
70
+
71
+
[[package]]
72
+
name = "ipython-pygments-lexers"
73
+
version = "1.1.1"
74
+
source = { registry = "https://pypi.org/simple" }
75
+
dependencies = [
76
+
{ name = "pygments" },
77
+
]
78
+
sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" }
79
+
wheels = [
80
+
{ url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" },
81
+
]
82
+
83
+
[[package]]
84
+
name = "jedi"
85
+
version = "0.19.2"
86
+
source = { registry = "https://pypi.org/simple" }
87
+
dependencies = [
88
+
{ name = "parso" },
89
+
]
90
+
sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
91
+
wheels = [
92
+
{ url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
93
+
]
94
+
95
+
[[package]]
96
+
name = "junit-xml"
97
+
version = "1.9"
98
+
source = { registry = "https://pypi.org/simple" }
99
+
dependencies = [
100
+
{ name = "six" },
101
+
]
102
+
sdist = { url = "https://files.pythonhosted.org/packages/98/af/bc988c914dd1ea2bc7540ecc6a0265c2b6faccc6d9cdb82f20e2094a8229/junit-xml-1.9.tar.gz", hash = "sha256:de16a051990d4e25a3982b2dd9e89d671067548718866416faec14d9de56db9f", size = 7349, upload-time = "2023-01-24T18:42:00.836Z" }
103
+
wheels = [
104
+
{ url = "https://files.pythonhosted.org/packages/2a/93/2d896b5fd3d79b4cadd8882c06650e66d003f465c9d12c488d92853dff78/junit_xml-1.9-py2.py3-none-any.whl", hash = "sha256:ec5ca1a55aefdd76d28fcc0b135251d156c7106fa979686a4b48d62b761b4732", size = 7130, upload-time = "2020-02-22T20:41:37.661Z" },
105
+
]
106
+
107
+
[[package]]
108
+
name = "matplotlib-inline"
109
+
version = "0.2.1"
110
+
source = { registry = "https://pypi.org/simple" }
111
+
dependencies = [
112
+
{ name = "traitlets" },
113
+
]
114
+
sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" }
115
+
wheels = [
116
+
{ url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" },
117
+
]
118
+
119
+
[[package]]
120
+
name = "nixos-test-driver"
121
+
version = "0.0.0"
122
+
source = { git = "https://github.com/NixOS/nixpkgs?subdirectory=nixos%2Flib%2Ftest-driver%2Fsrc&branch=nixos-25.11#c6f52ebd45e5925c188d1a20119978aa4ffd5ef6" }
123
+
124
+
[[package]]
125
+
name = "parso"
126
+
version = "0.8.5"
127
+
source = { registry = "https://pypi.org/simple" }
128
+
sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" }
129
+
wheels = [
130
+
{ url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
131
+
]
132
+
133
+
[[package]]
134
+
name = "pexpect"
135
+
version = "4.9.0"
136
+
source = { registry = "https://pypi.org/simple" }
137
+
dependencies = [
138
+
{ name = "ptyprocess" },
139
+
]
140
+
sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
141
+
wheels = [
142
+
{ url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
143
+
]
144
+
145
+
[[package]]
146
+
name = "prompt-toolkit"
147
+
version = "3.0.52"
148
+
source = { registry = "https://pypi.org/simple" }
149
+
dependencies = [
150
+
{ name = "wcwidth" },
151
+
]
152
+
sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
153
+
wheels = [
154
+
{ url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
155
+
]
156
+
157
+
[[package]]
158
+
name = "ptpython"
159
+
version = "3.0.32"
160
+
source = { registry = "https://pypi.org/simple" }
161
+
dependencies = [
162
+
{ name = "appdirs" },
163
+
{ name = "jedi" },
164
+
{ name = "prompt-toolkit" },
165
+
{ name = "pygments" },
166
+
]
167
+
sdist = { url = "https://files.pythonhosted.org/packages/b6/8c/7e904ceeb512b4530c7ca1d918d3565d694a1fa7df337cdfc36a16347d68/ptpython-3.0.32.tar.gz", hash = "sha256:11651778236de95c582b42737294e50a66ba4a21fa01c0090ea70815af478fe0", size = 74080, upload-time = "2025-11-20T21:20:48.27Z" }
168
+
wheels = [
169
+
{ url = "https://files.pythonhosted.org/packages/4c/ac/0e35e5d7afd47ab0e2c71293ed2ad18df91a2a4a008c0ff59c2f22def377/ptpython-3.0.32-py3-none-any.whl", hash = "sha256:16435d323e5fc0a685d5f4dc5bb4494fb68ac68736689cd1247e1eda9369b616", size = 68099, upload-time = "2025-11-20T21:20:46.634Z" },
170
+
]
171
+
172
+
[[package]]
173
+
name = "ptyprocess"
174
+
version = "0.7.0"
175
+
source = { registry = "https://pypi.org/simple" }
176
+
sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
177
+
wheels = [
178
+
{ url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
179
+
]
180
+
181
+
[[package]]
182
+
name = "pure-eval"
183
+
version = "0.2.3"
184
+
source = { registry = "https://pypi.org/simple" }
185
+
sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
186
+
wheels = [
187
+
{ url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
188
+
]
189
+
190
+
[[package]]
191
+
name = "pygments"
192
+
version = "2.19.2"
193
+
source = { registry = "https://pypi.org/simple" }
194
+
sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
195
+
wheels = [
196
+
{ url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
197
+
]
198
+
199
+
[[package]]
200
+
name = "remote-pdb"
201
+
version = "2.1.0"
202
+
source = { registry = "https://pypi.org/simple" }
203
+
sdist = { url = "https://files.pythonhosted.org/packages/e4/b5/4944cac06fd9fc4a2e168313ec220aa25ed96ce83947b63eea5b4045b22d/remote-pdb-2.1.0.tar.gz", hash = "sha256:2d70c6f41e0eabf0165e8f1be58f82aa7a605aaeab8f2aefeb9ce246431091c1", size = 22295, upload-time = "2020-07-24T13:31:32.985Z" }
204
+
wheels = [
205
+
{ url = "https://files.pythonhosted.org/packages/71/c5/d208c66344bb785d800adb61aef512290d3473052b9e7697890f0547aff2/remote_pdb-2.1.0-py2.py3-none-any.whl", hash = "sha256:94f73a92ac1248cf16189211011f97096bdada8a7baac8c79372663bbb57b5d0", size = 6304, upload-time = "2020-07-24T13:31:31.535Z" },
206
+
]
207
+
208
+
[[package]]
209
+
name = "six"
210
+
version = "1.17.0"
211
+
source = { registry = "https://pypi.org/simple" }
212
+
sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
213
+
wheels = [
214
+
{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
215
+
]
216
+
217
+
[[package]]
218
+
name = "stack-data"
219
+
version = "0.6.3"
220
+
source = { registry = "https://pypi.org/simple" }
221
+
dependencies = [
222
+
{ name = "asttokens" },
223
+
{ name = "executing" },
224
+
{ name = "pure-eval" },
225
+
]
226
+
sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
227
+
wheels = [
228
+
{ url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
229
+
]
230
+
231
+
[[package]]
232
+
name = "traitlets"
233
+
version = "5.14.3"
234
+
source = { registry = "https://pypi.org/simple" }
235
+
sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
236
+
wheels = [
237
+
{ url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
238
+
]
239
+
240
+
[[package]]
241
+
name = "ty"
242
+
version = "0.0.4"
243
+
source = { registry = "https://pypi.org/simple" }
244
+
sdist = { url = "https://files.pythonhosted.org/packages/48/d9/97d5808e851f790e58f8a54efb5c7b9f404640baf9e295f424846040b316/ty-0.0.4.tar.gz", hash = "sha256:2ea47a0089d74730658ec4e988c8ef476a1e9bd92df3e56709c4003c2895ff3b", size = 4780289, upload-time = "2025-12-19T00:13:53.12Z" }
245
+
wheels = [
246
+
{ url = "https://files.pythonhosted.org/packages/b1/94/b32a962243cc8a16e8dc74cf1fe75e8bb013d0e13e71bb540e2c86214b61/ty-0.0.4-py3-none-linux_armv6l.whl", hash = "sha256:5225da65a8d1defeb21ee9d74298b1b97c6cbab36e235a310c1430d9079e4b6a", size = 9762399, upload-time = "2025-12-19T00:14:11.261Z" },
247
+
{ url = "https://files.pythonhosted.org/packages/d1/d2/7c76e0c22ddfc2fcd4a3458a65f87ce074070eb1c68c07ee475cc2b6ea68/ty-0.0.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f87770d7988f470b795a2043185082fa959dbe1979a11b4bfe20f1214d37bd6e", size = 9590410, upload-time = "2025-12-19T00:13:55.759Z" },
248
+
{ url = "https://files.pythonhosted.org/packages/a5/84/de4b1fc85669faca3622071d5a3f3ec7bfb239971f368c28fae461d3398a/ty-0.0.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:ecf68b8ea48674a289d733b4786aecc259242a2d9a920b3ec8583db18c67496a", size = 9131113, upload-time = "2025-12-19T00:14:08.593Z" },
249
+
{ url = "https://files.pythonhosted.org/packages/a7/ff/b5bf385b6983be56a470856bbcbac1b7e816bcd765a7e9d39ab2399e387d/ty-0.0.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efc396d76a57e527393cae4ee8faf23b93be3df9e93202f39925721a7a2bb7b8", size = 9599152, upload-time = "2025-12-19T00:13:40.484Z" },
250
+
{ url = "https://files.pythonhosted.org/packages/36/d6/9880ba106f2f20d13e6a5dca5d5ca44bfb3782936ee67ff635f89a2959c0/ty-0.0.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c893b968d2f9964a4d4db9992c9ba66b01f411b1f48dffcde08622e19cd6ab97", size = 9585368, upload-time = "2025-12-19T00:14:00.994Z" },
251
+
{ url = "https://files.pythonhosted.org/packages/3f/53/503cfc18bc4c7c4e02f89dd43debc41a6e343b41eb43df658dfb493a386d/ty-0.0.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:526c925b80d68a53c165044d2370fcfc0def1f119f7b7e483ee61d24da6fb891", size = 9998412, upload-time = "2025-12-19T00:14:18.653Z" },
252
+
{ url = "https://files.pythonhosted.org/packages/1d/bd/dd2d3e29834da5add2eda0ab5b433171ce9ce9a248c364d2e237f82073d7/ty-0.0.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:857f605a7fa366b6c6e6f38abc311d0606be513c2bee8977b5c8fd4bde1a82d5", size = 10853890, upload-time = "2025-12-19T00:13:50.891Z" },
253
+
{ url = "https://files.pythonhosted.org/packages/07/fe/28ba3be1672e6b8df46e43de66a02dc076ffba7853d391a5466421886225/ty-0.0.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b4cc981aa3ebdac2c233421b1e58c80b0df6a8e6e6fa8b9e69fbdfd2f82768af", size = 10587263, upload-time = "2025-12-19T00:14:21.577Z" },
254
+
{ url = "https://files.pythonhosted.org/packages/26/9c/bb598772043f686afe5bc26cb386020709c1a0bcc164bc22ad9da2b4f55d/ty-0.0.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b03b2708b0bf67c76424a860f848aebaa4772c05529170c3761bfcaea93ec199", size = 10401204, upload-time = "2025-12-19T00:13:43.453Z" },
255
+
{ url = "https://files.pythonhosted.org/packages/ac/18/71765e9d63669bf09461c3fea84a7a63232ccb0e83b84676f07b987fc217/ty-0.0.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:469890e885544beb129c21e2f8f15321f0573d094aec13da68593c5f86389ff9", size = 10129713, upload-time = "2025-12-19T00:14:13.725Z" },
256
+
{ url = "https://files.pythonhosted.org/packages/c3/2d/c03eba570aa85e9c361de5ed36d60b9ab139e93ee91057f455ab4af48e54/ty-0.0.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:abfd928d09567e12068aeca875e920def3badf1978896f474aa4b85b552703c4", size = 9586203, upload-time = "2025-12-19T00:14:03.423Z" },
257
+
{ url = "https://files.pythonhosted.org/packages/61/f1/8c3c82a8df69bd4417c77be4f895d043db26dd47bfcc90b33dc109cd0096/ty-0.0.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:44b8e94f9d64df12eae4cf8031c5ca9a4c610b57092b26ad3d68d91bcc7af122", size = 9608230, upload-time = "2025-12-19T00:13:58.252Z" },
258
+
{ url = "https://files.pythonhosted.org/packages/51/0c/d8ba3a85c089c246ef6bd49d0f0b40bc0f9209bb819e8c02ccbea5cb4d57/ty-0.0.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9d6a439813e21a06769daf858105818c385d88018929d4a56970d4ddd5cd3df2", size = 9725125, upload-time = "2025-12-19T00:14:05.996Z" },
259
+
{ url = "https://files.pythonhosted.org/packages/4d/38/e30f64ad1e40905c766576ec70cffc69163591a5842ce14652672f6ab394/ty-0.0.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:c3cfcf26cfe6c828e91d7a529cc2dda37bc3b51ba06909c9be07002a6584af52", size = 10237174, upload-time = "2025-12-19T00:14:23.858Z" },
260
+
{ url = "https://files.pythonhosted.org/packages/cb/d7/8d650aa0be8936dd3ed74e2b0655230e2904caa6077c30c16a089b523cff/ty-0.0.4-py3-none-win32.whl", hash = "sha256:58bbf70dd27af6b00dedbdebeec92d5993aa238664f96fa5c0064930f7a0d30b", size = 9188434, upload-time = "2025-12-19T00:13:45.875Z" },
261
+
{ url = "https://files.pythonhosted.org/packages/82/d7/9fc0c81cf0b0d281ac9c18bfbdb4d6bae2173503ba79e40b210ab41c2c8b/ty-0.0.4-py3-none-win_amd64.whl", hash = "sha256:7c2db0f96218f08c140bd9d3fcbb1b3c8c5c4f0c9b0a5624487f0a2bf4b76163", size = 10019313, upload-time = "2025-12-19T00:14:15.968Z" },
262
+
{ url = "https://files.pythonhosted.org/packages/5f/b8/3e3246738eed1cd695c5964a401f3b9c757d20ac21fdae06281af9f40ef6/ty-0.0.4-py3-none-win_arm64.whl", hash = "sha256:69f14fc98e4a847afa9f8c5d5234d008820dbc09c7dcdb3ac1ba16628f5132df", size = 9561857, upload-time = "2025-12-19T00:13:48.382Z" },
263
+
]
264
+
265
+
[[package]]
266
+
name = "wcwidth"
267
+
version = "0.2.14"
268
+
source = { registry = "https://pypi.org/simple" }
269
+
sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" }
270
+
wheels = [
271
+
{ url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" },
272
+
]
273
+
274
+
[[package]]
275
+
name = "wire-vm-tests"
276
+
version = "0.0.0"
277
+
source = { virtual = "." }
278
+
dependencies = [
279
+
{ name = "colorama" },
280
+
{ name = "ipython" },
281
+
{ name = "junit-xml" },
282
+
{ name = "nixos-test-driver" },
283
+
{ name = "ptpython" },
284
+
{ name = "remote-pdb" },
285
+
]
286
+
287
+
[package.dev-dependencies]
288
+
dev = [
289
+
{ name = "ty" },
290
+
]
291
+
292
+
[package.metadata]
293
+
requires-dist = [
294
+
{ name = "colorama", specifier = ">=0.4.6" },
295
+
{ name = "ipython", specifier = ">=9.8.0" },
296
+
{ name = "junit-xml", specifier = ">=1.9" },
297
+
{ name = "nixos-test-driver", git = "https://github.com/NixOS/nixpkgs?subdirectory=nixos%2Flib%2Ftest-driver%2Fsrc&branch=nixos-25.11" },
298
+
{ name = "ptpython", specifier = ">=3.0.32" },
299
+
{ name = "remote-pdb", specifier = ">=2.1.0" },
300
+
]
301
+
302
+
[package.metadata.requires-dev]
303
+
dev = [{ name = "ty", specifier = ">=0.0.4" }]
-17
wire/agent/Cargo.toml
-17
wire/agent/Cargo.toml
···
1
-
[package]
2
-
name = "agent"
3
-
edition.workspace = true
4
-
version.workspace = true
5
-
6
-
[dependencies]
7
-
tokio = { workspace = true }
8
-
tokio-util = { workspace = true }
9
-
anyhow = { workspace = true }
10
-
prost = { workspace = true }
11
-
nix = { workspace = true }
12
-
futures-util = { workspace = true }
13
-
sha2 = { workspace = true }
14
-
base64 = { workspace = true }
15
-
16
-
[build-dependencies]
17
-
prost-build = "0.14"
-8
wire/agent/build.rs
-8
wire/agent/build.rs
-17
wire/agent/default.nix
-17
wire/agent/default.nix
-17
wire/agent/src/keys.proto
-17
wire/agent/src/keys.proto
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
syntax = "proto3";
5
-
6
-
package agent.keys;
7
-
8
-
message KeySpec {
9
-
string destination = 1;
10
-
string user = 2;
11
-
string group = 3;
12
-
uint32 permissions = 4;
13
-
uint32 length = 5;
14
-
bool last = 6;
15
-
/// Sha256 digest
16
-
bytes digest = 7;
17
-
}
-6
wire/agent/src/lib.rs
-6
wire/agent/src/lib.rs
-94
wire/agent/src/main.rs
-94
wire/agent/src/main.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#![deny(clippy::pedantic)]
5
-
use agent::keys::KeySpec;
6
-
use base64::Engine;
7
-
use base64::prelude::BASE64_STANDARD;
8
-
use futures_util::stream::StreamExt;
9
-
use nix::unistd::{Group, User};
10
-
use prost::Message;
11
-
use prost::bytes::Bytes;
12
-
use sha2::{Digest, Sha256};
13
-
use std::os::unix::fs::PermissionsExt;
14
-
use std::os::unix::fs::chown;
15
-
use std::path::{Path, PathBuf};
16
-
use tokio::fs::File;
17
-
use tokio::io::AsyncWriteExt;
18
-
use tokio_util::codec::{FramedRead, LengthDelimitedCodec};
19
-
20
-
fn create_path(key_path: &Path) -> Result<(), anyhow::Error> {
21
-
let prefix = key_path.parent().unwrap();
22
-
std::fs::create_dir_all(prefix)?;
23
-
24
-
Ok(())
25
-
}
26
-
27
-
fn pretty_keyspec(spec: &KeySpec) -> String {
28
-
format!(
29
-
"{} {}:{} {}",
30
-
spec.destination, spec.user, spec.group, spec.permissions
31
-
)
32
-
}
33
-
34
-
#[tokio::main]
35
-
async fn main() -> Result<(), anyhow::Error> {
36
-
let stdin = tokio::io::stdin();
37
-
38
-
let mut framed = FramedRead::new(stdin, LengthDelimitedCodec::new());
39
-
40
-
while let Some(spec_bytes) = framed.next().await {
41
-
let spec_bytes = Bytes::from(BASE64_STANDARD.decode(spec_bytes?)?);
42
-
let spec = KeySpec::decode(spec_bytes)?;
43
-
44
-
let key_bytes = BASE64_STANDARD.decode(
45
-
framed
46
-
.next()
47
-
.await
48
-
.expect("expected key_bytes to come after spec_bytes")?,
49
-
)?;
50
-
51
-
let digest = Sha256::digest(&key_bytes).to_vec();
52
-
53
-
println!(
54
-
"Writing {}, {:?} bytes of data",
55
-
pretty_keyspec(&spec),
56
-
key_bytes.len()
57
-
);
58
-
59
-
if digest != spec.digest {
60
-
return Err(anyhow::anyhow!(
61
-
"digest of {spec:?} did not match {digest:?}! Please create an issue!"
62
-
));
63
-
}
64
-
65
-
let path = PathBuf::from(&spec.destination);
66
-
create_path(&path)?;
67
-
68
-
let mut file = File::create(path).await?;
69
-
let mut permissions = file.metadata().await?.permissions();
70
-
71
-
permissions.set_mode(spec.permissions);
72
-
file.set_permissions(permissions).await?;
73
-
74
-
let user = User::from_name(&spec.user)?;
75
-
let group = Group::from_name(&spec.group)?;
76
-
77
-
chown(
78
-
spec.destination,
79
-
// Default uid/gid to 0. This is then wrapped around an Option again for
80
-
// the function.
81
-
Some(user.map_or(0, |user| user.uid.into())),
82
-
Some(group.map_or(0, |group| group.gid.into())),
83
-
)?;
84
-
85
-
file.write_all(&key_bytes).await?;
86
-
87
-
// last key, goobye
88
-
if spec.last {
89
-
break;
90
-
}
91
-
}
92
-
93
-
Ok(())
94
-
}
-33
wire/cli/Cargo.toml
-33
wire/cli/Cargo.toml
···
1
-
[package]
2
-
name = "wire"
3
-
version.workspace = true
4
-
edition.workspace = true
5
-
6
-
[lints]
7
-
workspace = true
8
-
9
-
[features]
10
-
dhat-heap = []
11
-
12
-
[dependencies]
13
-
clap = { workspace = true }
14
-
clap-verbosity-flag = { workspace = true }
15
-
serde = { workspace = true }
16
-
tokio = { workspace = true }
17
-
tracing = { workspace = true }
18
-
tracing-log = { workspace = true }
19
-
tracing-subscriber = { workspace = true }
20
-
lib = { path = "../lib" }
21
-
serde_json = { workspace = true }
22
-
miette = { workspace = true }
23
-
thiserror = { workspace = true }
24
-
enum-display-derive = "0.1.1"
25
-
im = { workspace = true }
26
-
futures = "0.3.31"
27
-
clap-num = "1.2.0"
28
-
clap-markdown = "0.1.5"
29
-
itertools = "0.14.0"
30
-
dhat = "0.3.2"
31
-
clap_complete = { version = "4.5.60", features = ["unstable-dynamic"] }
32
-
nix-compat = { workspace = true }
33
-
owo-colors = { workspace = true }
-98
wire/cli/default.nix
-98
wire/cli/default.nix
···
1
-
{ getSystem, inputs, ... }:
2
-
{
3
-
perSystem =
4
-
{
5
-
pkgs,
6
-
lib,
7
-
self',
8
-
buildRustProgram,
9
-
system,
10
-
...
11
-
}:
12
-
let
13
-
cleanSystem = system: lib.replaceStrings [ "-" ] [ "_" ] system;
14
-
agents = lib.strings.concatMapStrings (
15
-
system: "--set WIRE_AGENT_${cleanSystem system} ${(getSystem system).packages.agent} "
16
-
) (import inputs.linux-systems);
17
-
in
18
-
{
19
-
packages = {
20
-
default = self'.packages.wire;
21
-
wire-unwrapped = buildRustProgram {
22
-
name = "wire";
23
-
pname = "wire";
24
-
cargoExtraArgs = "-p wire";
25
-
doCheck = true;
26
-
nativeBuildInputs = [
27
-
pkgs.installShellFiles
28
-
pkgs.sqlx-cli
29
-
];
30
-
preBuild = ''
31
-
export DATABASE_URL=sqlite:./db.sqlite3
32
-
sqlx database create
33
-
sqlx migrate run --source ./wire/lib/src/cache/migrations/
34
-
'';
35
-
postInstall = ''
36
-
installShellCompletion --cmd wire \
37
-
--bash <(COMPLETE=bash $out/bin/wire) \
38
-
--fish <(COMPLETE=fish $out/bin/wire) \
39
-
--zsh <(COMPLETE=zsh $out/bin/wire)
40
-
'';
41
-
};
42
-
43
-
wire-unwrapped-dev = self'.packages.wire-unwrapped.overrideAttrs {
44
-
CARGO_PROFILE = "dev";
45
-
};
46
-
47
-
wire-unwrapped-perf = buildRustProgram {
48
-
name = "wire";
49
-
pname = "wire";
50
-
CARGO_PROFILE = "profiling";
51
-
cargoExtraArgs = "-p wire";
52
-
};
53
-
54
-
wire = pkgs.symlinkJoin {
55
-
name = "wire";
56
-
paths = [ self'.packages.wire-unwrapped ];
57
-
nativeBuildInputs = [
58
-
pkgs.makeWrapper
59
-
];
60
-
postBuild = ''
61
-
wrapProgram $out/bin/wire ${agents}
62
-
'';
63
-
meta.mainProgram = "wire";
64
-
};
65
-
66
-
wire-small = pkgs.symlinkJoin {
67
-
name = "wire";
68
-
paths = [ self'.packages.wire-unwrapped ];
69
-
nativeBuildInputs = [
70
-
pkgs.makeWrapper
71
-
];
72
-
postBuild = ''
73
-
wrapProgram $out/bin/wire --set WIRE_AGENT_${cleanSystem system} ${self'.packages.agent}
74
-
'';
75
-
meta.mainProgram = "wire";
76
-
};
77
-
78
-
wire-dev = self'.packages.wire.overrideAttrs {
79
-
paths = [ self'.packages.wire-unwrapped-dev ];
80
-
};
81
-
82
-
wire-small-dev = self'.packages.wire-small.overrideAttrs {
83
-
paths = [ self'.packages.wire-unwrapped-dev ];
84
-
};
85
-
86
-
wire-small-perf = self'.packages.wire-small.overrideAttrs {
87
-
paths = [ self'.packages.wire-unwrapped-perf ];
88
-
};
89
-
90
-
wire-diagnostics-md = self'.packages.wire-unwrapped.overrideAttrs {
91
-
DIAGNOSTICS_MD_OUTPUT = "/build/source";
92
-
installPhase = ''
93
-
mv /build/source/DIAGNOSTICS.md $out
94
-
'';
95
-
};
96
-
};
97
-
};
98
-
}
-171
wire/cli/src/apply.rs
-171
wire/cli/src/apply.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use futures::{FutureExt, StreamExt};
5
-
use itertools::{Either, Itertools};
6
-
use lib::hive::node::{Context, GoalExecutor, Name, StepState, should_apply_locally};
7
-
use lib::hive::{Hive, HiveLocation};
8
-
use lib::status::STATUS;
9
-
use lib::{SubCommandModifiers, errors::HiveLibError};
10
-
use miette::{Diagnostic, IntoDiagnostic, Result};
11
-
use std::collections::HashSet;
12
-
use std::io::{Read, stderr};
13
-
use std::sync::Arc;
14
-
use thiserror::Error;
15
-
use tracing::{Span, error, info};
16
-
17
-
use crate::cli::{ApplyArgs, ApplyTarget};
18
-
19
-
#[derive(Debug, Error, Diagnostic)]
20
-
#[error("node {} failed to apply", .0)]
21
-
struct NodeError(
22
-
Name,
23
-
#[source]
24
-
#[diagnostic_source]
25
-
HiveLibError,
26
-
);
27
-
28
-
#[derive(Debug, Error, Diagnostic)]
29
-
#[error("{} node(s) failed to apply.", .0.len())]
30
-
struct NodeErrors(#[related] Vec<NodeError>);
31
-
32
-
// returns Names and Tags
33
-
fn read_apply_targets_from_stdin() -> Result<(Vec<String>, Vec<Name>)> {
34
-
let mut buf = String::new();
35
-
let mut stdin = std::io::stdin().lock();
36
-
stdin.read_to_string(&mut buf).into_diagnostic()?;
37
-
38
-
Ok(buf
39
-
.split_whitespace()
40
-
.map(|x| ApplyTarget::from(x.to_string()))
41
-
.fold((Vec::new(), Vec::new()), |(mut tags, mut names), target| {
42
-
match target {
43
-
ApplyTarget::Node(name) => names.push(name),
44
-
ApplyTarget::Tag(tag) => tags.push(tag),
45
-
ApplyTarget::Stdin => {}
46
-
}
47
-
(tags, names)
48
-
}))
49
-
}
50
-
51
-
// #[instrument(skip_all, fields(goal = %args.goal, on = %args.on.iter().join(", ")))]
52
-
pub async fn apply(
53
-
hive: &mut Hive,
54
-
location: HiveLocation,
55
-
args: ApplyArgs,
56
-
mut modifiers: SubCommandModifiers,
57
-
) -> Result<()> {
58
-
let header_span = Span::current();
59
-
let location = Arc::new(location);
60
-
61
-
// Respect user's --always-build-local arg
62
-
hive.force_always_local(args.always_build_local)?;
63
-
64
-
let header_span_enter = header_span.enter();
65
-
66
-
let (tags, names) = args.on.iter().fold(
67
-
(HashSet::new(), HashSet::new()),
68
-
|(mut tags, mut names), target| {
69
-
match target {
70
-
ApplyTarget::Tag(tag) => {
71
-
tags.insert(tag.clone());
72
-
}
73
-
ApplyTarget::Node(name) => {
74
-
names.insert(name.clone());
75
-
}
76
-
ApplyTarget::Stdin => {
77
-
// implies non_interactive
78
-
modifiers.non_interactive = true;
79
-
80
-
let (found_tags, found_names) = read_apply_targets_from_stdin().unwrap();
81
-
names.extend(found_names);
82
-
tags.extend(found_tags);
83
-
}
84
-
}
85
-
(tags, names)
86
-
},
87
-
);
88
-
89
-
let selected_nodes: Vec<_> = hive
90
-
.nodes
91
-
.iter_mut()
92
-
.filter(|(name, node)| {
93
-
args.on.is_empty()
94
-
|| names.contains(name)
95
-
|| node.tags.iter().any(|tag| tags.contains(tag))
96
-
})
97
-
.collect();
98
-
99
-
STATUS.lock().add_many(
100
-
&selected_nodes
101
-
.iter()
102
-
.map(|(name, _)| *name)
103
-
.collect::<Vec<_>>(),
104
-
);
105
-
106
-
let mut set = selected_nodes
107
-
.into_iter()
108
-
.map(|(name, node)| {
109
-
info!("Resolved {:?} to include {}", args.on, name);
110
-
111
-
let should_apply_locally = should_apply_locally(node.allow_local_deployment, &name.0);
112
-
113
-
let context = Context {
114
-
node,
115
-
name,
116
-
goal: args.goal.clone().try_into().unwrap(),
117
-
state: StepState::default(),
118
-
no_keys: args.no_keys,
119
-
hive_location: location.clone(),
120
-
modifiers,
121
-
reboot: args.reboot,
122
-
should_apply_locally,
123
-
handle_unreachable: args.handle_unreachable.clone().into(),
124
-
};
125
-
126
-
GoalExecutor::new(context)
127
-
.execute()
128
-
.map(move |result| (name, result))
129
-
})
130
-
.peekable();
131
-
132
-
if set.peek().is_none() {
133
-
error!("There are no nodes selected for deployment");
134
-
}
135
-
136
-
let futures = futures::stream::iter(set).buffer_unordered(args.parallel);
137
-
let result = futures.collect::<Vec<_>>().await;
138
-
let (successful, errors): (Vec<_>, Vec<_>) =
139
-
result
140
-
.into_iter()
141
-
.partition_map(|(name, result)| match result {
142
-
Ok(..) => Either::Left(name),
143
-
Err(err) => Either::Right((name, err)),
144
-
});
145
-
146
-
if !successful.is_empty() {
147
-
info!(
148
-
"Successfully applied goal to {} node(s): {:?}",
149
-
successful.len(),
150
-
successful
151
-
);
152
-
}
153
-
154
-
std::mem::drop(header_span_enter);
155
-
std::mem::drop(header_span);
156
-
157
-
if !errors.is_empty() {
158
-
// clear the status bar if we are about to print error messages
159
-
STATUS.lock().clear(&mut stderr());
160
-
161
-
return Err(NodeErrors(
162
-
errors
163
-
.into_iter()
164
-
.map(|(name, error)| NodeError(name.clone(), error))
165
-
.collect(),
166
-
)
167
-
.into());
168
-
}
169
-
170
-
Ok(())
171
-
}
-305
wire/cli/src/cli.rs
-305
wire/cli/src/cli.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use clap::builder::PossibleValue;
5
-
use clap::{Args, Parser, Subcommand, ValueEnum};
6
-
use clap::{ValueHint, crate_version};
7
-
use clap_complete::CompletionCandidate;
8
-
use clap_complete::engine::ArgValueCompleter;
9
-
use clap_num::number_range;
10
-
use clap_verbosity_flag::InfoLevel;
11
-
use lib::SubCommandModifiers;
12
-
use lib::commands::common::get_hive_node_names;
13
-
use lib::hive::node::{Goal as HiveGoal, HandleUnreachable, Name, SwitchToConfigurationGoal};
14
-
use lib::hive::{Hive, get_hive_location};
15
-
use tokio::runtime::Handle;
16
-
17
-
use std::io::IsTerminal;
18
-
use std::{
19
-
fmt::{self, Display, Formatter},
20
-
sync::Arc,
21
-
};
22
-
23
-
#[allow(clippy::struct_excessive_bools)]
24
-
#[derive(Parser)]
25
-
#[command(
26
-
name = "wire",
27
-
bin_name = "wire",
28
-
about = "a tool to deploy nixos systems",
29
-
version = format!("{}\nDebug: Hive::SCHEMA_VERSION {}", crate_version!(), Hive::SCHEMA_VERSION)
30
-
)]
31
-
pub struct Cli {
32
-
#[command(subcommand)]
33
-
pub command: Commands,
34
-
35
-
#[command(flatten)]
36
-
pub verbose: clap_verbosity_flag::Verbosity<InfoLevel>,
37
-
38
-
/// Path or flake reference
39
-
#[arg(long, global = true, default_value = std::env::current_dir().unwrap().into_os_string(), visible_alias("flake"))]
40
-
pub path: String,
41
-
42
-
/// Hide progress bars.
43
-
///
44
-
/// Defaults to true if stdin does not refer to a tty (unix pipelines, in CI).
45
-
#[arg(long, global = true, default_value_t = !std::io::stdin().is_terminal())]
46
-
pub no_progress: bool,
47
-
48
-
/// Never accept user input.
49
-
///
50
-
/// Defaults to true if stdin does not refer to a tty (unix pipelines, in CI).
51
-
#[arg(long, global = true, default_value_t = !std::io::stdin().is_terminal())]
52
-
pub non_interactive: bool,
53
-
54
-
/// Show trace logs
55
-
#[arg(long, global = true, default_value_t = false)]
56
-
pub show_trace: bool,
57
-
58
-
#[cfg(debug_assertions)]
59
-
#[arg(long, hide = true, global = true)]
60
-
pub markdown_help: bool,
61
-
}
62
-
63
-
#[derive(Clone, Debug)]
64
-
pub enum ApplyTarget {
65
-
Node(Name),
66
-
Tag(String),
67
-
Stdin,
68
-
}
69
-
70
-
impl From<String> for ApplyTarget {
71
-
fn from(value: String) -> Self {
72
-
if value == "-" {
73
-
return ApplyTarget::Stdin;
74
-
}
75
-
76
-
if let Some(stripped) = value.strip_prefix("@") {
77
-
ApplyTarget::Tag(stripped.to_string())
78
-
} else {
79
-
ApplyTarget::Node(Name(Arc::from(value.as_str())))
80
-
}
81
-
}
82
-
}
83
-
84
-
impl Display for ApplyTarget {
85
-
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
86
-
match self {
87
-
ApplyTarget::Node(name) => name.fmt(f),
88
-
ApplyTarget::Tag(tag) => write!(f, "@{tag}"),
89
-
ApplyTarget::Stdin => write!(f, "#stdin"),
90
-
}
91
-
}
92
-
}
93
-
94
-
fn more_than_zero(s: &str) -> Result<usize, String> {
95
-
number_range(s, 1, usize::MAX)
96
-
}
97
-
98
-
#[derive(Clone)]
99
-
pub enum HandleUnreachableArg {
100
-
Ignore,
101
-
FailNode,
102
-
}
103
-
104
-
impl Display for HandleUnreachableArg {
105
-
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
106
-
match self {
107
-
Self::Ignore => write!(f, "ignore"),
108
-
Self::FailNode => write!(f, "fail-node"),
109
-
}
110
-
}
111
-
}
112
-
113
-
impl clap::ValueEnum for HandleUnreachableArg {
114
-
fn value_variants<'a>() -> &'a [Self] {
115
-
&[Self::Ignore, Self::FailNode]
116
-
}
117
-
118
-
fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
119
-
match self {
120
-
Self::Ignore => Some(PossibleValue::new("ignore")),
121
-
Self::FailNode => Some(PossibleValue::new("fail-node")),
122
-
}
123
-
}
124
-
}
125
-
126
-
impl From<HandleUnreachableArg> for HandleUnreachable {
127
-
fn from(value: HandleUnreachableArg) -> Self {
128
-
match value {
129
-
HandleUnreachableArg::Ignore => Self::Ignore,
130
-
HandleUnreachableArg::FailNode => Self::FailNode,
131
-
}
132
-
}
133
-
}
134
-
135
-
#[derive(Args)]
136
-
pub struct ApplyArgs {
137
-
#[arg(value_enum, default_value_t)]
138
-
pub goal: Goal,
139
-
140
-
/// List of literal node names, a literal `-`, or `@` prefixed tags.
141
-
///
142
-
/// `-` will read additional values from stdin, separated by whitespace.
143
-
/// Any `-` implies `--non-interactive`.
144
-
#[arg(short, long, value_name = "NODE | @TAG | `-`", num_args = 1.., add = ArgValueCompleter::new(node_names_completer), value_hint = ValueHint::Unknown)]
145
-
pub on: Vec<ApplyTarget>,
146
-
147
-
#[arg(short, long, default_value_t = 10, value_parser=more_than_zero)]
148
-
pub parallel: usize,
149
-
150
-
/// Skip key uploads. noop when [GOAL] = Keys
151
-
#[arg(short, long, default_value_t = false)]
152
-
pub no_keys: bool,
153
-
154
-
/// Overrides deployment.buildOnTarget.
155
-
#[arg(short, long, value_name = "NODE")]
156
-
pub always_build_local: Vec<String>,
157
-
158
-
/// Reboot the nodes after activation
159
-
#[arg(short, long, default_value_t = false)]
160
-
pub reboot: bool,
161
-
162
-
/// How to handle an unreachable node in the ping step.
163
-
///
164
-
/// This only effects the ping step.
165
-
/// wire will still fail the node if it becomes unreachable after activation
166
-
#[arg(long, default_value_t = HandleUnreachableArg::FailNode)]
167
-
pub handle_unreachable: HandleUnreachableArg,
168
-
169
-
/// Unconditionally accept SSH host keys [!!]
170
-
///
171
-
/// Sets `StrictHostKeyChecking` to `no`.
172
-
/// Vulnerable to man-in-the-middle attacks, use with caution.
173
-
#[arg(long, default_value_t = false)]
174
-
pub ssh_accept_host: bool,
175
-
}
176
-
177
-
#[derive(Subcommand)]
178
-
pub enum Commands {
179
-
/// Deploy nodes
180
-
Apply(ApplyArgs),
181
-
/// Inspect hive
182
-
#[clap(visible_alias = "show")]
183
-
Inspect {
184
-
#[arg(value_enum, default_value_t)]
185
-
selection: Inspection,
186
-
187
-
/// Return in JSON format
188
-
#[arg(short, long, default_value_t = false)]
189
-
json: bool,
190
-
},
191
-
}
192
-
193
-
#[derive(Clone, Debug, Default, ValueEnum, Display)]
194
-
pub enum Inspection {
195
-
/// Output all data wire has on the entire hive
196
-
#[default]
197
-
Full,
198
-
/// Only output a list of node names
199
-
Names,
200
-
}
201
-
202
-
#[derive(Clone, Debug, Default, ValueEnum, Display)]
203
-
pub enum Goal {
204
-
/// Make the configuration the boot default and activate now
205
-
#[default]
206
-
Switch,
207
-
/// Build the configuration but do nothing with it
208
-
Build,
209
-
/// Copy system derivation to remote hosts
210
-
Push,
211
-
/// Push deployment keys to remote hosts
212
-
Keys,
213
-
/// Activate system profile on next boot
214
-
Boot,
215
-
/// Activate the configuration, but don't make it the boot default
216
-
Test,
217
-
/// Show what would be done if this configuration were activated.
218
-
DryActivate,
219
-
}
220
-
221
-
impl TryFrom<Goal> for HiveGoal {
222
-
type Error = miette::Error;
223
-
224
-
fn try_from(value: Goal) -> Result<Self, Self::Error> {
225
-
match value {
226
-
Goal::Build => Ok(HiveGoal::Build),
227
-
Goal::Push => Ok(HiveGoal::Push),
228
-
Goal::Boot => Ok(HiveGoal::SwitchToConfiguration(
229
-
SwitchToConfigurationGoal::Boot,
230
-
)),
231
-
Goal::Switch => Ok(HiveGoal::SwitchToConfiguration(
232
-
SwitchToConfigurationGoal::Switch,
233
-
)),
234
-
Goal::Test => Ok(HiveGoal::SwitchToConfiguration(
235
-
SwitchToConfigurationGoal::Test,
236
-
)),
237
-
Goal::DryActivate => Ok(HiveGoal::SwitchToConfiguration(
238
-
SwitchToConfigurationGoal::DryActivate,
239
-
)),
240
-
Goal::Keys => Ok(HiveGoal::Keys),
241
-
}
242
-
}
243
-
}
244
-
245
-
pub trait ToSubCommandModifiers {
246
-
fn to_subcommand_modifiers(&self) -> SubCommandModifiers;
247
-
}
248
-
249
-
impl ToSubCommandModifiers for Cli {
250
-
fn to_subcommand_modifiers(&self) -> SubCommandModifiers {
251
-
SubCommandModifiers {
252
-
show_trace: self.show_trace,
253
-
non_interactive: self.non_interactive,
254
-
ssh_accept_host: match &self.command {
255
-
Commands::Apply(args) if args.ssh_accept_host => lib::StrictHostKeyChecking::No,
256
-
_ => lib::StrictHostKeyChecking::default(),
257
-
},
258
-
}
259
-
}
260
-
}
261
-
262
-
fn node_names_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidate> {
263
-
tokio::task::block_in_place(|| {
264
-
let handle = Handle::current();
265
-
let modifiers = SubCommandModifiers::default();
266
-
let mut completions = vec![];
267
-
268
-
if current.is_empty() || current == "-" {
269
-
completions.push(
270
-
CompletionCandidate::new("-").help(Some("Read stdin as --on arguments".into())),
271
-
);
272
-
}
273
-
274
-
let Ok(current_dir) = std::env::current_dir() else {
275
-
return completions;
276
-
};
277
-
278
-
let Ok(hive_location) = handle.block_on(get_hive_location(
279
-
current_dir.display().to_string(),
280
-
modifiers,
281
-
)) else {
282
-
return completions;
283
-
};
284
-
285
-
let Some(current) = current.to_str() else {
286
-
return completions;
287
-
};
288
-
289
-
if current.starts_with('@') {
290
-
return vec![];
291
-
}
292
-
293
-
if let Ok(names) =
294
-
handle.block_on(async { get_hive_node_names(&hive_location, modifiers).await })
295
-
{
296
-
for name in names {
297
-
if name.starts_with(current) {
298
-
completions.push(CompletionCandidate::new(name));
299
-
}
300
-
}
301
-
}
302
-
303
-
completions
304
-
})
305
-
}
-113
wire/cli/src/main.rs
-113
wire/cli/src/main.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#![feature(sync_nonpoison)]
5
-
#![feature(nonpoison_mutex)]
6
-
7
-
use std::process::Command;
8
-
9
-
use crate::cli::Cli;
10
-
use crate::cli::ToSubCommandModifiers;
11
-
use crate::tracing_setup::setup_logging;
12
-
use clap::CommandFactory;
13
-
use clap::Parser;
14
-
use clap_complete::CompleteEnv;
15
-
use lib::cache::InspectionCache;
16
-
use lib::commands::common::get_hive_node_names;
17
-
use lib::hive::Hive;
18
-
use lib::hive::get_hive_location;
19
-
use miette::IntoDiagnostic;
20
-
use miette::Result;
21
-
use tracing::error;
22
-
use tracing::warn;
23
-
24
-
#[macro_use]
25
-
extern crate enum_display_derive;
26
-
27
-
mod apply;
28
-
mod cli;
29
-
mod tracing_setup;
30
-
31
-
#[cfg(feature = "dhat-heap")]
32
-
#[global_allocator]
33
-
static ALLOC: dhat::Alloc = dhat::Alloc;
34
-
35
-
#[tokio::main]
36
-
async fn main() -> Result<()> {
37
-
#[cfg(feature = "dhat-heap")]
38
-
let _profiler = dhat::Profiler::new_heap();
39
-
CompleteEnv::with_factory(Cli::command).complete();
40
-
41
-
let args = Cli::parse();
42
-
43
-
let modifiers = args.to_subcommand_modifiers();
44
-
// disable progress when running inspect mode.
45
-
setup_logging(
46
-
&args.verbose,
47
-
!matches!(args.command, cli::Commands::Inspect { .. }) && !&args.no_progress,
48
-
);
49
-
50
-
#[cfg(debug_assertions)]
51
-
if args.markdown_help {
52
-
clap_markdown::print_help_markdown::<Cli>();
53
-
return Ok(());
54
-
}
55
-
56
-
if !check_nix_available() {
57
-
miette::bail!("Nix is not available on this system.");
58
-
}
59
-
60
-
let location = get_hive_location(args.path, modifiers).await?;
61
-
let cache = InspectionCache::new().await;
62
-
63
-
match args.command {
64
-
cli::Commands::Apply(apply_args) => {
65
-
let mut hive = Hive::new_from_path(&location, cache.clone(), modifiers).await?;
66
-
apply::apply(&mut hive, location, apply_args, modifiers).await?;
67
-
}
68
-
cli::Commands::Inspect { json, selection } => println!("{}", {
69
-
match selection {
70
-
cli::Inspection::Full => {
71
-
let hive = Hive::new_from_path(&location, cache.clone(), modifiers).await?;
72
-
if json {
73
-
serde_json::to_string(&hive).into_diagnostic()?
74
-
} else {
75
-
warn!("use --json to output something scripting suitable");
76
-
format!("{hive}")
77
-
}
78
-
}
79
-
cli::Inspection::Names => {
80
-
serde_json::to_string(&get_hive_node_names(&location, modifiers).await?)
81
-
.into_diagnostic()?
82
-
}
83
-
}
84
-
}),
85
-
}
86
-
87
-
if let Some(cache) = cache {
88
-
cache.gc().await.into_diagnostic()?;
89
-
}
90
-
91
-
Ok(())
92
-
}
93
-
94
-
fn check_nix_available() -> bool {
95
-
match Command::new("nix")
96
-
.stdout(std::process::Stdio::null())
97
-
.stderr(std::process::Stdio::null())
98
-
.spawn()
99
-
{
100
-
Ok(_) => true,
101
-
Err(e) => {
102
-
if let std::io::ErrorKind::NotFound = e.kind() {
103
-
false
104
-
} else {
105
-
error!(
106
-
"Something weird happened checking for nix availability, {}",
107
-
e
108
-
);
109
-
false
110
-
}
111
-
}
112
-
}
113
-
}
-284
wire/cli/src/tracing_setup.rs
-284
wire/cli/src/tracing_setup.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::{
5
-
collections::VecDeque,
6
-
io::{self, Stderr, Write, stderr},
7
-
time::Duration,
8
-
};
9
-
10
-
use clap_verbosity_flag::{LogLevel, Verbosity};
11
-
use lib::{STDIN_CLOBBER_LOCK, status::STATUS};
12
-
use owo_colors::{OwoColorize, Stream, Style};
13
-
use tracing::{Level, Subscriber};
14
-
use tracing_log::AsTrace;
15
-
use tracing_subscriber::{
16
-
Layer,
17
-
field::{RecordFields, VisitFmt},
18
-
fmt::{
19
-
FormatEvent, FormatFields, FormattedFields,
20
-
format::{self, DefaultFields, DefaultVisitor, Format, Full},
21
-
},
22
-
layer::{Context, SubscriberExt},
23
-
registry::LookupSpan,
24
-
util::SubscriberInitExt,
25
-
};
26
-
27
-
/// The non-clobbering writer ensures that log lines are held while interactive
28
-
/// prompts are shown to the user. If logs where shown, they would "clobber" the
29
-
/// sudo / ssh prompt.
30
-
///
31
-
/// Additionally, the `STDIN_CLOBBER_LOCK` is used to ensure that no two
32
-
/// interactive prompts are shown at the same time.
33
-
struct NonClobberingWriter {
34
-
queue: VecDeque<Vec<u8>>,
35
-
stderr: Stderr,
36
-
}
37
-
38
-
impl NonClobberingWriter {
39
-
fn new() -> Self {
40
-
NonClobberingWriter {
41
-
queue: VecDeque::with_capacity(100),
42
-
stderr: stderr(),
43
-
}
44
-
}
45
-
46
-
/// expects the caller to write the status line
47
-
fn dump_previous(&mut self) -> Result<(), io::Error> {
48
-
STATUS.lock().clear(&mut self.stderr);
49
-
50
-
for buf in self.queue.iter().rev() {
51
-
self.stderr.write(buf).map(|_| ())?;
52
-
}
53
-
54
-
Ok(())
55
-
}
56
-
}
57
-
58
-
impl Write for NonClobberingWriter {
59
-
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
60
-
if let 1.. = STDIN_CLOBBER_LOCK.available_permits() {
61
-
self.dump_previous().map(|()| 0)?;
62
-
63
-
STATUS.lock().write_above_status(buf, &mut self.stderr)
64
-
} else {
65
-
self.queue.push_front(buf.to_vec());
66
-
67
-
Ok(buf.len())
68
-
}
69
-
}
70
-
71
-
fn flush(&mut self) -> std::io::Result<()> {
72
-
self.stderr.flush()
73
-
}
74
-
}
75
-
76
-
/// Handles event formatting, which falls back to the default formatter
77
-
/// passed.
78
-
struct WireEventFormat(Format<Full, ()>);
79
-
/// Formats the node's name with `WireFieldVisitor`
80
-
struct WireFieldFormat;
81
-
struct WireFieldVisitor<'a>(DefaultVisitor<'a>);
82
-
/// `WireLayer` injects `WireFieldFormat` as an extension on the event
83
-
struct WireLayer;
84
-
85
-
impl<'a> WireFieldVisitor<'a> {
86
-
fn new(writer: format::Writer<'a>, is_empty: bool) -> Self {
87
-
Self(DefaultVisitor::new(writer, is_empty))
88
-
}
89
-
}
90
-
91
-
impl<'writer> FormatFields<'writer> for WireFieldFormat {
92
-
fn format_fields<R: RecordFields>(
93
-
&self,
94
-
writer: format::Writer<'writer>,
95
-
fields: R,
96
-
) -> std::fmt::Result {
97
-
let mut v = WireFieldVisitor::new(writer, true);
98
-
fields.record(&mut v);
99
-
Ok(())
100
-
}
101
-
}
102
-
103
-
impl tracing::field::Visit for WireFieldVisitor<'_> {
104
-
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
105
-
if field.name() == "node" {
106
-
let _ = write!(
107
-
self.0.writer(),
108
-
"{:?}",
109
-
value.if_supports_color(Stream::Stderr, |text| text.bold())
110
-
);
111
-
}
112
-
}
113
-
}
114
-
115
-
const fn get_style(level: Level) -> Style {
116
-
let mut style = Style::new();
117
-
118
-
style = match level {
119
-
Level::TRACE => style.purple(),
120
-
Level::DEBUG => style.blue(),
121
-
Level::INFO => style.green(),
122
-
Level::WARN => style.yellow(),
123
-
Level::ERROR => style.red(),
124
-
};
125
-
126
-
style
127
-
}
128
-
129
-
const fn fmt_level(level: Level) -> &'static str {
130
-
match level {
131
-
Level::TRACE => "TRACE",
132
-
Level::DEBUG => "DEBUG",
133
-
Level::INFO => " INFO",
134
-
Level::WARN => " WARN",
135
-
Level::ERROR => "ERROR",
136
-
}
137
-
}
138
-
139
-
impl<S, N> FormatEvent<S, N> for WireEventFormat
140
-
where
141
-
S: Subscriber + for<'a> LookupSpan<'a>,
142
-
N: for<'a> FormatFields<'a> + 'static,
143
-
{
144
-
fn format_event(
145
-
&self,
146
-
ctx: &tracing_subscriber::fmt::FmtContext<'_, S, N>,
147
-
mut writer: tracing_subscriber::fmt::format::Writer<'_>,
148
-
event: &tracing::Event<'_>,
149
-
) -> std::fmt::Result {
150
-
let metadata = event.metadata();
151
-
152
-
// skip events without an "event_scope"
153
-
let Some(scope) = ctx.event_scope() else {
154
-
return self.0.format_event(ctx, writer, event);
155
-
};
156
-
157
-
// skip spans without a parent
158
-
let Some(parent) = scope.last() else {
159
-
return self.0.format_event(ctx, writer, event);
160
-
};
161
-
162
-
// skip spans that dont refer to the goal step executor
163
-
if parent.name() != "execute" {
164
-
return self.0.format_event(ctx, writer, event);
165
-
}
166
-
167
-
// skip spans that dont refer to a specific node being executed
168
-
if parent.fields().field("node").is_none() {
169
-
return self.0.format_event(ctx, writer, event);
170
-
}
171
-
172
-
let style = get_style(*metadata.level());
173
-
174
-
// write the log level with colour
175
-
write!(
176
-
writer,
177
-
"{} ",
178
-
fmt_level(*metadata.level()).if_supports_color(Stream::Stderr, |x| { x.style(style) })
179
-
)?;
180
-
181
-
// extract the formatted node name into a string
182
-
let parent_ext = parent.extensions();
183
-
let node_name = &parent_ext
184
-
.get::<FormattedFields<WireFieldFormat>>()
185
-
.unwrap();
186
-
187
-
write!(writer, "{node_name}")?;
188
-
189
-
// write the step name
190
-
if let Some(step) = ctx.event_scope().unwrap().from_root().nth(1) {
191
-
write!(writer, " {}", step.name().italic())?;
192
-
}
193
-
194
-
write!(writer, " | ")?;
195
-
196
-
// write the default fields, including the actual message and other data
197
-
let mut fields = FormattedFields::<DefaultFields>::new(String::new());
198
-
199
-
ctx.format_fields(fields.as_writer(), event)?;
200
-
201
-
write!(writer, "{fields}")?;
202
-
writeln!(writer)?;
203
-
204
-
Ok(())
205
-
}
206
-
}
207
-
208
-
impl<S> Layer<S> for WireLayer
209
-
where
210
-
S: Subscriber + for<'a> LookupSpan<'a>,
211
-
{
212
-
fn on_new_span(
213
-
&self,
214
-
attrs: &tracing::span::Attributes<'_>,
215
-
id: &tracing::span::Id,
216
-
ctx: Context<'_, S>,
217
-
) {
218
-
let span = ctx.span(id).unwrap();
219
-
220
-
if span.extensions().get::<WireFieldFormat>().is_some() {
221
-
return;
222
-
}
223
-
224
-
let mut fields = FormattedFields::<WireFieldFormat>::new(String::new());
225
-
if WireFieldFormat
226
-
.format_fields(fields.as_writer(), attrs)
227
-
.is_ok()
228
-
{
229
-
span.extensions_mut().insert(fields);
230
-
}
231
-
}
232
-
}
233
-
234
-
async fn status_tick_worker() {
235
-
let mut interval = tokio::time::interval(Duration::from_secs(1));
236
-
let mut stderr = stderr();
237
-
238
-
loop {
239
-
interval.tick().await;
240
-
241
-
if STDIN_CLOBBER_LOCK.available_permits() < 1 {
242
-
continue;
243
-
}
244
-
245
-
let mut status = STATUS.lock();
246
-
247
-
status.clear(&mut stderr);
248
-
status.write_status(&mut stderr);
249
-
}
250
-
}
251
-
252
-
/// Set up logging for the application
253
-
/// Uses `WireFieldFormat` if -v was never passed
254
-
pub fn setup_logging<L: LogLevel>(verbosity: &Verbosity<L>, show_progress: bool) {
255
-
let filter = verbosity.log_level_filter().as_trace();
256
-
let registry = tracing_subscriber::registry();
257
-
258
-
STATUS.lock().show_progress(show_progress);
259
-
260
-
// spawn worker to tick the status bar
261
-
if show_progress {
262
-
tokio::spawn(status_tick_worker());
263
-
}
264
-
265
-
if verbosity.is_present() {
266
-
let layer = tracing_subscriber::fmt::layer()
267
-
.without_time()
268
-
.with_target(false)
269
-
.with_writer(NonClobberingWriter::new)
270
-
.with_filter(filter);
271
-
272
-
registry.with(layer).init();
273
-
return;
274
-
}
275
-
276
-
let event_formatter = WireEventFormat(format::format().without_time().with_target(false));
277
-
278
-
let layer = tracing_subscriber::fmt::layer()
279
-
.event_format(event_formatter)
280
-
.with_writer(NonClobberingWriter::new)
281
-
.with_filter(filter);
282
-
283
-
registry.with(layer).with(WireLayer).init();
284
-
}
-51
wire/lib/Cargo.toml
-51
wire/lib/Cargo.toml
···
1
-
[package]
2
-
name = "lib"
3
-
version.workspace = true
4
-
edition.workspace = true
5
-
6
-
[lints]
7
-
workspace = true
8
-
9
-
[features]
10
-
no_web_tests = []
11
-
12
-
[dependencies]
13
-
tokio = { workspace = true }
14
-
serde = { workspace = true }
15
-
serde_json = { workspace = true }
16
-
tracing = { workspace = true }
17
-
im = { workspace = true }
18
-
thiserror = "2.0.17"
19
-
derive_more = { version = "2.0.1", features = ["display"] }
20
-
agent = { path = "../agent" }
21
-
futures = "0.3.31"
22
-
prost = { workspace = true }
23
-
gethostname = "1.1.0"
24
-
nix.workspace = true
25
-
miette = { workspace = true }
26
-
rand = "0.9.2"
27
-
tokio-util = { workspace = true }
28
-
portable-pty = "0.9.0"
29
-
anyhow.workspace = true
30
-
itertools = "0.14.0"
31
-
enum_dispatch = "0.3.13"
32
-
sha2 = { workspace = true }
33
-
base64 = { workspace = true }
34
-
nix-compat = { workspace = true }
35
-
strip-ansi-escapes = "0.2.1"
36
-
aho-corasick = "1.1.4"
37
-
num_enum = "0.7.5"
38
-
gjson = "0.8.1"
39
-
owo-colors = { workspace = true }
40
-
termion = "4.0.6"
41
-
sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] }
42
-
zstd = "0.13.3"
43
-
44
-
[dev-dependencies]
45
-
tempdir = "0.3"
46
-
47
-
[build-dependencies]
48
-
miette = { workspace = true }
49
-
syn = "2.0.109"
50
-
proc-macro2 = "1.0.103"
51
-
itertools = "0.14.0"
-206
wire/lib/build.rs
-206
wire/lib/build.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use miette::{Context, IntoDiagnostic as _, Result, miette};
5
-
use std::fmt::Write;
6
-
use std::{
7
-
env,
8
-
fmt::{self, Display, Formatter},
9
-
fs::{self},
10
-
path::Path,
11
-
};
12
-
13
-
use itertools::Itertools;
14
-
use proc_macro2::TokenTree;
15
-
use syn::{Expr, Item, ItemEnum, Lit, Meta, MetaList, MetaNameValue, parse_file};
16
-
17
-
macro_rules! p {
18
-
($($tokens: tt)*) => {
19
-
println!("cargo::warning={}", format!($($tokens)*))
20
-
}
21
-
}
22
-
23
-
#[derive(Debug)]
24
-
struct DerivedError {
25
-
code: Option<String>,
26
-
help: Option<String>,
27
-
message: Option<String>,
28
-
doc_string: String,
29
-
}
30
-
31
-
impl Display for DerivedError {
32
-
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
33
-
write!(
34
-
f,
35
-
"## `{code}` {{#{code}}}
36
-
37
-
{doc}
38
-
{message}
39
-
{help}",
40
-
doc = self.doc_string,
41
-
code = self.code.as_ref().unwrap(),
42
-
help = match &self.help {
43
-
Some(help) => format!(
44
-
"
45
-
::: tip HELP
46
-
{help}
47
-
:::"
48
-
),
49
-
None => String::new(),
50
-
},
51
-
message = match &self.message {
52
-
Some(message) => format!(
53
-
"
54
-
```txt [message]
55
-
{message}
56
-
```"
57
-
),
58
-
None => String::new(),
59
-
}
60
-
)
61
-
}
62
-
}
63
-
64
-
impl DerivedError {
65
-
fn get_error(&mut self, list: &MetaList) -> Result<(), miette::Error> {
66
-
if list.path.segments.last().unwrap().ident != "error" {
67
-
return Err(miette!("Not an error"));
68
-
}
69
-
70
-
self.message = Some(
71
-
list.tokens
72
-
.clone()
73
-
.into_iter()
74
-
.filter(|tok| matches!(tok, TokenTree::Literal(tok) if tok.to_string().starts_with('"')))
75
-
.map(|tok| tok.to_string())
76
-
.join(""),
77
-
);
78
-
79
-
Err(miette!("No error msg found"))
80
-
}
81
-
82
-
fn update_diagnostic(&mut self, list: &MetaList) -> Result<(), miette::Error> {
83
-
if list.path.segments.last().unwrap().ident != "diagnostic" {
84
-
return Err(miette!("Not a diagnostic"));
85
-
}
86
-
87
-
let vec: Vec<_> = list.tokens.clone().into_iter().collect();
88
-
89
-
// Find `diagnostic(code(x::y::z))`
90
-
let code: Option<String> = if let Some((_, TokenTree::Group(group))) =
91
-
vec.iter().tuple_windows().find(|(ident, group)| {
92
-
matches!(ident, TokenTree::Ident(ident) if ident == "code")
93
-
&& matches!(group, TokenTree::Group(..))
94
-
}) {
95
-
Some(group.stream().to_string().replace(' ', ""))
96
-
} else {
97
-
None
98
-
};
99
-
100
-
// Find `diagnostic(help("hi"))`
101
-
let help: Option<String> = if let Some((_, TokenTree::Group(group))) =
102
-
vec.iter().tuple_windows().find(|(ident, group)| {
103
-
matches!(ident, TokenTree::Ident(ident) if ident == "help")
104
-
&& matches!(group, TokenTree::Group(..))
105
-
}) {
106
-
Some(group.stream().to_string())
107
-
} else {
108
-
None
109
-
};
110
-
111
-
if let Some(code) = code {
112
-
self.code = Some(code);
113
-
self.help = help;
114
-
return Ok(());
115
-
}
116
-
117
-
Err(miette!("Had no code."))
118
-
}
119
-
120
-
fn update_from_list(&mut self, list: &MetaList) {
121
-
let _ = self.get_error(list);
122
-
let _ = self.update_diagnostic(list);
123
-
}
124
-
125
-
fn update_from_namevalue(&mut self, list: MetaNameValue) -> Result<(), miette::Error> {
126
-
if list.path.segments.last().unwrap().ident != "doc" {
127
-
return Err(miette!("Not a doc string"));
128
-
}
129
-
130
-
if let Expr::Lit(lit) = list.value
131
-
&& let Lit::Str(str) = lit.lit
132
-
{
133
-
let _ = write!(self.doc_string, "{}\n\n", &str.value()[1..]);
134
-
}
135
-
136
-
Ok(())
137
-
}
138
-
}
139
-
140
-
fn main() -> Result<()> {
141
-
println!("cargo:rerun-if-changed=src/errors.rs");
142
-
143
-
let manifest_dir = env::var("CARGO_MANIFEST_DIR").into_diagnostic()?;
144
-
let Ok(md_out_dir) = env::var("DIAGNOSTICS_MD_OUTPUT") else {
145
-
return Ok(());
146
-
};
147
-
148
-
let src_path = Path::new(&manifest_dir).join("src/errors.rs");
149
-
let src = fs::read_to_string(&src_path)
150
-
.into_diagnostic()
151
-
.wrap_err("reading errors.rs")?;
152
-
153
-
let syntax_tree = parse_file(&src)
154
-
.into_diagnostic()
155
-
.wrap_err("parsing errors.rs")?;
156
-
let mut entries: Vec<DerivedError> = Vec::new();
157
-
158
-
for item in &syntax_tree.items {
159
-
if let Item::Enum(ItemEnum { variants, .. }) = item {
160
-
for variant in variants {
161
-
let mut entry = DerivedError {
162
-
code: None,
163
-
help: None,
164
-
message: None,
165
-
doc_string: String::new(),
166
-
};
167
-
168
-
for attribute in variant.attrs.clone() {
169
-
match attribute.meta {
170
-
Meta::List(list) => {
171
-
entry.update_from_list(&list);
172
-
}
173
-
Meta::NameValue(nv) => {
174
-
let _ = entry.update_from_namevalue(nv);
175
-
}
176
-
Meta::Path(_) => {}
177
-
}
178
-
}
179
-
180
-
if entry.code.is_some() {
181
-
entries.push(entry);
182
-
}
183
-
}
184
-
}
185
-
}
186
-
187
-
fs::create_dir_all(Path::new(&md_out_dir))
188
-
.into_diagnostic()
189
-
.wrap_err("creating target directory")?;
190
-
fs::write(
191
-
Path::new(&md_out_dir).join("DIAGNOSTICS.md"),
192
-
entries
193
-
.iter()
194
-
.map(std::string::ToString::to_string)
195
-
.join("\n\n"),
196
-
)
197
-
.into_diagnostic()
198
-
.wrap_err("writing DIAGNOSTICS.md")?;
199
-
200
-
p!(
201
-
"wrote to {:?}",
202
-
Path::new(&md_out_dir).join("DIAGNOSTICS.md")
203
-
);
204
-
205
-
Ok(())
206
-
}
-13
wire/lib/src/cache/migrations/20251124234730_init.sql
-13
wire/lib/src/cache/migrations/20251124234730_init.sql
···
1
-
create table hive_inspection (
2
-
id integer primary key autoincrement,
3
-
json_value text not null unique
4
-
) strict;
5
-
6
-
create table cached_inspection (
7
-
store_path text,
8
-
hash text,
9
-
10
-
inspection_id integer references hive_inspection(id) not null,
11
-
12
-
primary key (store_path, hash)
13
-
) strict;
-16
wire/lib/src/cache/migrations/20251126222409_blobs.sql
-16
wire/lib/src/cache/migrations/20251126222409_blobs.sql
···
1
-
create table inspection_blobs (
2
-
id integer primary key autoincrement,
3
-
json_value blob not null unique,
4
-
schema_version integer not null
5
-
) strict;
6
-
7
-
create table inspection_cache (
8
-
store_path text,
9
-
hash text,
10
-
blob_id integer references inspection_blobs (id) not null,
11
-
primary key (store_path, hash)
12
-
) strict;
13
-
14
-
drop table cached_inspection;
15
-
16
-
drop table hive_inspection;
-205
wire/lib/src/cache/mod.rs
-205
wire/lib/src/cache/mod.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::{env, path::PathBuf};
5
-
6
-
use sqlx::{
7
-
Pool, Sqlite,
8
-
migrate::Migrator,
9
-
sqlite::{SqliteConnectOptions, SqlitePoolOptions},
10
-
};
11
-
use tokio::fs::create_dir_all;
12
-
use tracing::{debug, error, trace};
13
-
14
-
use crate::hive::{FlakePrefetch, Hive};
15
-
16
-
#[derive(Clone)]
17
-
pub struct InspectionCache {
18
-
pool: Pool<Sqlite>,
19
-
}
20
-
21
-
static MIGRATOR: Migrator = sqlx::migrate!("src/cache/migrations");
22
-
23
-
async fn get_cache_directory() -> Option<PathBuf> {
24
-
let home = PathBuf::from(
25
-
env::var("HOME")
26
-
.inspect_err(|_| error!("HOME env var not found"))
27
-
.ok()?,
28
-
);
29
-
30
-
trace!(home = ?home);
31
-
32
-
let cache_home = env::var("XDG_CACHE_HOME")
33
-
.inspect_err(|_| debug!("XDG_CACHE_HOME not found"))
34
-
.ok()
35
-
.map(PathBuf::from)
36
-
.unwrap_or(home.join(".cache"));
37
-
38
-
let cache_directory = cache_home.join("wire");
39
-
40
-
trace!(cache_directory = ?cache_directory);
41
-
42
-
let _ = create_dir_all(&cache_directory).await;
43
-
44
-
Some(cache_directory)
45
-
}
46
-
47
-
impl InspectionCache {
48
-
pub async fn new() -> Option<Self> {
49
-
let cache_path = get_cache_directory().await?.join("inspect.db");
50
-
debug!(cache_path = ?cache_path);
51
-
52
-
let pool = SqlitePoolOptions::new()
53
-
.max_connections(1)
54
-
.connect_with(
55
-
SqliteConnectOptions::new()
56
-
.filename(cache_path)
57
-
.create_if_missing(true),
58
-
)
59
-
.await
60
-
.inspect_err(|x| error!("failed to open cache db: {x}"))
61
-
.ok()?;
62
-
63
-
MIGRATOR
64
-
.run(&pool)
65
-
.await
66
-
.inspect_err(|err| error!("failed to run cache migrations: {err:?}"))
67
-
.ok()?;
68
-
69
-
Some(Self { pool })
70
-
}
71
-
72
-
pub async fn get_hive(&self, prefetch: &FlakePrefetch) -> Option<Hive> {
73
-
let cached_blob: Vec<u8> = sqlx::query_scalar!(
74
-
"
75
-
select inspection_blobs.json_value from inspection_blobs
76
-
join inspection_cache
77
-
on inspection_cache.blob_id = inspection_blobs.id
78
-
where inspection_cache.store_path = $1
79
-
and inspection_cache.hash = $2
80
-
and inspection_blobs.schema_version = $3
81
-
limit 1
82
-
",
83
-
prefetch.store_path,
84
-
prefetch.hash,
85
-
Hive::SCHEMA_VERSION
86
-
)
87
-
.fetch_optional(&self.pool)
88
-
.await
89
-
.inspect_err(|x| error!("failed to fetch cached hive: {x}"))
90
-
.ok()??;
91
-
92
-
trace!("read {} bytes of zstd data from cache", cached_blob.len());
93
-
94
-
let json_string = zstd::decode_all(cached_blob.as_slice())
95
-
.inspect_err(|err| error!("failed to decode cached zstd data: {err}"))
96
-
.ok()?;
97
-
98
-
trace!(
99
-
"inflated {} > {} in decoding",
100
-
cached_blob.len(),
101
-
json_string.len()
102
-
);
103
-
104
-
serde_json::from_slice(&json_string)
105
-
.inspect_err(|err| {
106
-
error!("could not use cached evaluation: {err}");
107
-
})
108
-
.ok()
109
-
}
110
-
111
-
pub async fn store_hive(&self, prefetch: &FlakePrefetch, json_value: &String) {
112
-
let Ok(json_value) = zstd::encode_all(json_value.as_bytes(), 0)
113
-
.inspect_err(|err| error!("failed to encode data w/ zstd: {err}"))
114
-
else {
115
-
return;
116
-
};
117
-
118
-
let hive_inspection = sqlx::query_scalar!(
119
-
"
120
-
insert into inspection_blobs (json_value, schema_version)
121
-
values ($1, $2)
122
-
on conflict(json_value)
123
-
do update set json_value = excluded.json_value
124
-
returning inspection_blobs.id
125
-
",
126
-
json_value,
127
-
Hive::SCHEMA_VERSION
128
-
)
129
-
.fetch_one(&self.pool)
130
-
.await
131
-
.inspect_err(|x| error!("could not insert hive_inspection: {x}"));
132
-
133
-
let Ok(blob_id) = hive_inspection else {
134
-
return;
135
-
};
136
-
137
-
let cached_inspection = sqlx::query!(
138
-
"
139
-
insert into
140
-
inspection_cache (store_path, hash, blob_id)
141
-
values
142
-
($1, $2, $3)
143
-
",
144
-
prefetch.store_path,
145
-
prefetch.hash,
146
-
blob_id
147
-
)
148
-
.execute(&self.pool)
149
-
.await;
150
-
151
-
if let Err(err) = cached_inspection {
152
-
error!("could not insert cached_inspection: {err}");
153
-
}
154
-
}
155
-
156
-
pub async fn gc(&self) -> Result<(), sqlx::Error> {
157
-
// keep newest 30 AND
158
-
// delete caches that refer to a blob w/ wrong schmea
159
-
sqlx::query!(
160
-
"delete from inspection_cache
161
-
where
162
-
blob_id in (
163
-
select
164
-
id
165
-
from
166
-
inspection_blobs
167
-
where
168
-
schema_version != $1
169
-
)
170
-
or ROWID in (
171
-
select
172
-
ROWID
173
-
from
174
-
inspection_cache
175
-
order by
176
-
ROWID desc
177
-
limit
178
-
-1
179
-
offset
180
-
30
181
-
)",
182
-
Hive::SCHEMA_VERSION
183
-
)
184
-
.execute(&self.pool)
185
-
.await?;
186
-
187
-
// delete orphaned blobs
188
-
sqlx::query!(
189
-
"delete from inspection_blobs
190
-
where
191
-
not exists (
192
-
select
193
-
1
194
-
from
195
-
inspection_cache
196
-
where
197
-
inspection_cache.blob_id = inspection_blobs.id
198
-
)"
199
-
)
200
-
.execute(&self.pool)
201
-
.await?;
202
-
203
-
Ok(())
204
-
}
205
-
}
-162
wire/lib/src/commands/common.rs
-162
wire/lib/src/commands/common.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::collections::HashMap;
5
-
6
-
use tracing::instrument;
7
-
8
-
use crate::{
9
-
EvalGoal, SubCommandModifiers,
10
-
commands::{CommandArguments, Either, WireCommandChip, run_command, run_command_with_env},
11
-
errors::{CommandError, HiveInitialisationError, HiveLibError},
12
-
hive::{
13
-
HiveLocation,
14
-
node::{Context, Push},
15
-
},
16
-
};
17
-
18
-
fn get_common_copy_path_help(error: &CommandError) -> Option<String> {
19
-
if let CommandError::CommandFailed { logs, .. } = error
20
-
&& (logs.contains("error: unexpected end-of-file"))
21
-
{
22
-
Some("wire requires the deploying user or wire binary cache is trusted on the remote server. if you're attempting to make that change, skip keys with --no-keys. please read https://wire.althaea.zone/guides/keys for more information".to_string())
23
-
} else {
24
-
None
25
-
}
26
-
}
27
-
28
-
pub async fn push(context: &Context<'_>, push: Push<'_>) -> Result<(), HiveLibError> {
29
-
let command_string = format!(
30
-
"nix --extra-experimental-features nix-command \
31
-
copy --substitute-on-destination --to ssh://{user}@{host} {path}",
32
-
user = context.node.target.user,
33
-
host = context.node.target.get_preferred_host()?,
34
-
path = match push {
35
-
Push::Derivation(drv) => format!("{drv} --derivation"),
36
-
Push::Path(path) => path.clone(),
37
-
}
38
-
);
39
-
40
-
let child = run_command_with_env(
41
-
&CommandArguments::new(command_string, context.modifiers)
42
-
.mode(crate::commands::ChildOutputMode::Nix),
43
-
HashMap::from([(
44
-
"NIX_SSHOPTS".into(),
45
-
context
46
-
.node
47
-
.target
48
-
.create_ssh_opts(context.modifiers, false)?,
49
-
)]),
50
-
)
51
-
.await?;
52
-
53
-
let status = child.wait_till_success().await;
54
-
55
-
let help = if let Err(ref error) = status {
56
-
get_common_copy_path_help(error).map(Box::new)
57
-
} else {
58
-
None
59
-
};
60
-
61
-
status.map_err(|error| HiveLibError::NixCopyError {
62
-
name: context.name.clone(),
63
-
path: push.to_string(),
64
-
error: Box::new(error),
65
-
help,
66
-
})?;
67
-
68
-
Ok(())
69
-
}
70
-
71
-
fn get_common_command_help(error: &CommandError) -> Option<String> {
72
-
if let CommandError::CommandFailed { logs, .. } = error
73
-
// marshmallow: your using this repo as a hive you idiot
74
-
&& (logs.contains("attribute 'inspect' missing")
75
-
// using a flake that does not provide `wire`
76
-
|| logs.contains("does not provide attribute 'packages.x86_64-linux.wire'")
77
-
// using a file called `hive.nix` that is not actually a hive
78
-
|| logs.contains("attribute 'inspect' in selection path"))
79
-
{
80
-
Some("Double check this `--path` or `--flake` is a wire hive. You may be pointing to the wrong directory.".to_string())
81
-
} else {
82
-
None
83
-
}
84
-
}
85
-
86
-
pub async fn get_hive_node_names(
87
-
location: &HiveLocation,
88
-
modifiers: SubCommandModifiers,
89
-
) -> Result<Vec<String>, HiveLibError> {
90
-
let output = evaluate_hive_attribute(location, &EvalGoal::Names, modifiers).await?;
91
-
serde_json::from_str(&output).map_err(|err| {
92
-
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParseEvaluateError(err))
93
-
})
94
-
}
95
-
96
-
/// Evaluates the hive in flakeref with regards to the given goal,
97
-
/// and returns stdout.
98
-
#[instrument(ret(level = tracing::Level::TRACE), skip_all)]
99
-
pub async fn evaluate_hive_attribute(
100
-
location: &HiveLocation,
101
-
goal: &EvalGoal<'_>,
102
-
modifiers: SubCommandModifiers,
103
-
) -> Result<String, HiveLibError> {
104
-
let attribute = match location {
105
-
HiveLocation::Flake { uri, .. } => {
106
-
format!(
107
-
"{uri}#wire --apply \"hive: {}\"",
108
-
match goal {
109
-
EvalGoal::Inspect => "hive.inspect".to_string(),
110
-
EvalGoal::Names => "hive.names".to_string(),
111
-
EvalGoal::GetTopLevel(node) => format!("hive.topLevels.{node}"),
112
-
}
113
-
)
114
-
}
115
-
HiveLocation::HiveNix(path) => {
116
-
format!(
117
-
"--file {} {}",
118
-
&path.to_string_lossy(),
119
-
match goal {
120
-
EvalGoal::Inspect => "inspect".to_string(),
121
-
EvalGoal::Names => "names".to_string(),
122
-
EvalGoal::GetTopLevel(node) => format!("topLevels.{node}"),
123
-
}
124
-
)
125
-
}
126
-
};
127
-
128
-
let command_string = format!(
129
-
"nix --extra-experimental-features nix-command \
130
-
--extra-experimental-features flakes \
131
-
eval --json {mods} {attribute}",
132
-
mods = if modifiers.show_trace {
133
-
"--show-trace"
134
-
} else {
135
-
""
136
-
},
137
-
);
138
-
139
-
let child = run_command(
140
-
&CommandArguments::new(command_string, modifiers)
141
-
.mode(crate::commands::ChildOutputMode::Nix),
142
-
)
143
-
.await?;
144
-
145
-
let status = child.wait_till_success().await;
146
-
147
-
let help = if let Err(ref error) = status {
148
-
get_common_command_help(error).map(Box::new)
149
-
} else {
150
-
None
151
-
};
152
-
153
-
status
154
-
.map_err(|source| HiveLibError::NixEvalError {
155
-
attribute,
156
-
source,
157
-
help,
158
-
})
159
-
.map(|x| match x {
160
-
Either::Left((_, stdout)) | Either::Right((_, stdout)) => stdout,
161
-
})
162
-
}
-239
wire/lib/src/commands/mod.rs
-239
wire/lib/src/commands/mod.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use crate::commands::pty::{InteractiveChildChip, interactive_command_with_env};
5
-
use std::{collections::HashMap, str::from_utf8, sync::LazyLock};
6
-
7
-
use aho_corasick::AhoCorasick;
8
-
use gjson::Value;
9
-
use itertools::Itertools;
10
-
use nix_compat::log::{AT_NIX_PREFIX, VerbosityLevel};
11
-
use num_enum::TryFromPrimitive;
12
-
use tracing::{debug, error, info, trace, warn};
13
-
14
-
use crate::{
15
-
SubCommandModifiers,
16
-
commands::noninteractive::{NonInteractiveChildChip, non_interactive_command_with_env},
17
-
errors::{CommandError, HiveLibError},
18
-
hive::node::{Node, Target},
19
-
};
20
-
21
-
pub mod common;
22
-
pub(crate) mod noninteractive;
23
-
pub(crate) mod pty;
24
-
25
-
#[derive(Copy, Clone, Debug)]
26
-
pub(crate) enum ChildOutputMode {
27
-
Nix,
28
-
Generic,
29
-
Interactive,
30
-
}
31
-
32
-
#[derive(Debug)]
33
-
pub enum Either<L, R> {
34
-
Left(L),
35
-
Right(R),
36
-
}
37
-
38
-
#[derive(Debug)]
39
-
pub(crate) struct CommandArguments<'t, S: AsRef<str>> {
40
-
modifiers: SubCommandModifiers,
41
-
target: Option<&'t Target>,
42
-
output_mode: ChildOutputMode,
43
-
command_string: S,
44
-
keep_stdin_open: bool,
45
-
privilege_escalation_command: Option<String>,
46
-
log_stdout: bool,
47
-
}
48
-
49
-
static AHO_CORASICK: LazyLock<AhoCorasick> = LazyLock::new(|| {
50
-
AhoCorasick::builder()
51
-
.ascii_case_insensitive(false)
52
-
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
53
-
.build([AT_NIX_PREFIX])
54
-
.unwrap()
55
-
});
56
-
57
-
impl<'a, S: AsRef<str>> CommandArguments<'a, S> {
58
-
pub(crate) const fn new(command_string: S, modifiers: SubCommandModifiers) -> Self {
59
-
Self {
60
-
command_string,
61
-
keep_stdin_open: false,
62
-
privilege_escalation_command: None,
63
-
log_stdout: false,
64
-
target: None,
65
-
output_mode: ChildOutputMode::Generic,
66
-
modifiers,
67
-
}
68
-
}
69
-
70
-
pub(crate) const fn on_target(mut self, target: Option<&'a Target>) -> Self {
71
-
self.target = target;
72
-
self
73
-
}
74
-
75
-
pub(crate) const fn mode(mut self, mode: ChildOutputMode) -> Self {
76
-
self.output_mode = mode;
77
-
self
78
-
}
79
-
80
-
pub(crate) const fn keep_stdin_open(mut self) -> Self {
81
-
self.keep_stdin_open = true;
82
-
self
83
-
}
84
-
85
-
pub(crate) fn elevated(mut self, node: &Node) -> Self {
86
-
self.privilege_escalation_command =
87
-
Some(node.privilege_escalation_command.iter().join(" "));
88
-
self
89
-
}
90
-
91
-
pub(crate) const fn is_elevated(&self) -> bool {
92
-
self.privilege_escalation_command.is_some()
93
-
}
94
-
95
-
pub(crate) const fn log_stdout(mut self) -> Self {
96
-
self.log_stdout = true;
97
-
self
98
-
}
99
-
}
100
-
101
-
pub(crate) async fn run_command<S: AsRef<str>>(
102
-
arguments: &CommandArguments<'_, S>,
103
-
) -> Result<Either<InteractiveChildChip, NonInteractiveChildChip>, HiveLibError> {
104
-
run_command_with_env(arguments, HashMap::new()).await
105
-
}
106
-
107
-
pub(crate) async fn run_command_with_env<S: AsRef<str>>(
108
-
arguments: &CommandArguments<'_, S>,
109
-
envs: HashMap<String, String>,
110
-
) -> Result<Either<InteractiveChildChip, NonInteractiveChildChip>, HiveLibError> {
111
-
// use the non interactive command runner when forced
112
-
// ... or when there is no reason for interactivity, local and unprivileged
113
-
if arguments.modifiers.non_interactive
114
-
|| (arguments.target.is_none() && !arguments.is_elevated())
115
-
{
116
-
return Ok(Either::Right(non_interactive_command_with_env(
117
-
arguments, envs,
118
-
)?));
119
-
}
120
-
121
-
Ok(Either::Left(
122
-
interactive_command_with_env(arguments, envs).await?,
123
-
))
124
-
}
125
-
126
-
pub(crate) trait WireCommandChip {
127
-
type ExitStatus;
128
-
129
-
async fn wait_till_success(self) -> Result<Self::ExitStatus, CommandError>;
130
-
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError>;
131
-
}
132
-
133
-
type ExitStatus = Either<(portable_pty::ExitStatus, String), (std::process::ExitStatus, String)>;
134
-
135
-
impl WireCommandChip for Either<InteractiveChildChip, NonInteractiveChildChip> {
136
-
type ExitStatus = ExitStatus;
137
-
138
-
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
139
-
match self {
140
-
Self::Left(left) => left.write_stdin(data).await,
141
-
Self::Right(right) => right.write_stdin(data).await,
142
-
}
143
-
}
144
-
145
-
async fn wait_till_success(self) -> Result<Self::ExitStatus, CommandError> {
146
-
match self {
147
-
Self::Left(left) => left.wait_till_success().await.map(Either::Left),
148
-
Self::Right(right) => right.wait_till_success().await.map(Either::Right),
149
-
}
150
-
}
151
-
}
152
-
153
-
fn trace_gjson_str<'a>(log: &'a Value<'a>, msg: &'a str) -> Option<String> {
154
-
if msg.is_empty() {
155
-
return None;
156
-
}
157
-
158
-
let level = log.get("level");
159
-
160
-
if !level.exists() {
161
-
return None;
162
-
}
163
-
164
-
let level = match VerbosityLevel::try_from_primitive(level.u64()) {
165
-
Ok(level) => level,
166
-
Err(err) => {
167
-
error!("nix log `level` did not match to a VerbosityLevel: {err:?}");
168
-
return None;
169
-
}
170
-
};
171
-
172
-
let msg = strip_ansi_escapes::strip_str(msg);
173
-
174
-
match level {
175
-
VerbosityLevel::Info => info!("{msg}"),
176
-
VerbosityLevel::Warn | VerbosityLevel::Notice => warn!("{msg}"),
177
-
VerbosityLevel::Error => error!("{msg}"),
178
-
VerbosityLevel::Debug => debug!("{msg}"),
179
-
VerbosityLevel::Vomit | VerbosityLevel::Talkative | VerbosityLevel::Chatty => {
180
-
trace!("{msg}");
181
-
}
182
-
}
183
-
184
-
if matches!(
185
-
level,
186
-
VerbosityLevel::Error | VerbosityLevel::Warn | VerbosityLevel::Notice
187
-
) {
188
-
return Some(msg);
189
-
}
190
-
191
-
None
192
-
}
193
-
194
-
impl ChildOutputMode {
195
-
/// this function is by far the biggest hotspot in the whole tree
196
-
/// Returns a string if this log is notable to be stored as an error message
197
-
fn trace_slice(self, line: &mut [u8]) -> Option<String> {
198
-
let slice = match self {
199
-
Self::Generic | Self::Interactive => {
200
-
let string = String::from_utf8_lossy(line);
201
-
let stripped = strip_ansi_escapes::strip_str(&string);
202
-
warn!("{stripped}");
203
-
return Some(string.to_string());
204
-
}
205
-
Self::Nix => {
206
-
let position = AHO_CORASICK.find(&line).map(|x| &mut line[x.end()..]);
207
-
208
-
if let Some(json_buf) = position {
209
-
json_buf
210
-
} else {
211
-
// usually happens when ssh is outputting something
212
-
warn!("{}", String::from_utf8_lossy(line));
213
-
return None;
214
-
}
215
-
}
216
-
};
217
-
218
-
let Ok(str) = from_utf8(slice) else {
219
-
error!("nix log was not valid utf8!");
220
-
return None;
221
-
};
222
-
223
-
let log = gjson::parse(str);
224
-
225
-
let text = log.get("text");
226
-
227
-
if text.exists() {
228
-
return trace_gjson_str(&log, text.str());
229
-
}
230
-
231
-
let text = log.get("msg");
232
-
233
-
if text.exists() {
234
-
return trace_gjson_str(&log, text.str());
235
-
}
236
-
237
-
None
238
-
}
239
-
}
-199
wire/lib/src/commands/noninteractive.rs
-199
wire/lib/src/commands/noninteractive.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::{
5
-
collections::{HashMap, VecDeque},
6
-
process::ExitStatus,
7
-
sync::Arc,
8
-
};
9
-
10
-
use crate::{
11
-
SubCommandModifiers,
12
-
commands::{ChildOutputMode, CommandArguments, WireCommandChip},
13
-
errors::{CommandError, HiveLibError},
14
-
hive::node::Target,
15
-
};
16
-
use itertools::Itertools;
17
-
use tokio::{
18
-
io::{AsyncWriteExt, BufReader},
19
-
process::{Child, ChildStdin, Command},
20
-
sync::Mutex,
21
-
task::JoinSet,
22
-
};
23
-
use tracing::{Instrument, debug, instrument, trace};
24
-
25
-
pub(crate) struct NonInteractiveChildChip {
26
-
error_collection: Arc<Mutex<VecDeque<String>>>,
27
-
stdout_collection: Arc<Mutex<VecDeque<String>>>,
28
-
child: Child,
29
-
joinset: JoinSet<()>,
30
-
original_command: String,
31
-
stdin: ChildStdin,
32
-
}
33
-
34
-
#[instrument(skip_all, name = "run", fields(elevated = %arguments.is_elevated()))]
35
-
pub(crate) fn non_interactive_command_with_env<S: AsRef<str>>(
36
-
arguments: &CommandArguments<S>,
37
-
envs: HashMap<String, String>,
38
-
) -> Result<NonInteractiveChildChip, HiveLibError> {
39
-
let mut command = if let Some(target) = arguments.target {
40
-
create_sync_ssh_command(target, arguments.modifiers)?
41
-
} else {
42
-
let mut command = Command::new("sh");
43
-
44
-
command.arg("-c");
45
-
46
-
command
47
-
};
48
-
49
-
let command_string = format!(
50
-
"{command_string}{extra}",
51
-
command_string = arguments.command_string.as_ref(),
52
-
extra = match arguments.output_mode {
53
-
ChildOutputMode::Generic | ChildOutputMode::Interactive => "",
54
-
ChildOutputMode::Nix => " --log-format internal-json",
55
-
}
56
-
);
57
-
58
-
let command_string = if let Some(escalation_command) = &arguments.privilege_escalation_command {
59
-
format!("{escalation_command} sh -c '{command_string}'")
60
-
} else {
61
-
command_string
62
-
};
63
-
64
-
debug!("{command_string}");
65
-
66
-
command.arg(&command_string);
67
-
command.stdin(std::process::Stdio::piped());
68
-
command.stderr(std::process::Stdio::piped());
69
-
command.stdout(std::process::Stdio::piped());
70
-
command.kill_on_drop(true);
71
-
// command.env_clear();
72
-
command.envs(envs);
73
-
74
-
let mut child = command.spawn().unwrap();
75
-
let error_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
76
-
let stdout_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
77
-
let stdin = child.stdin.take().unwrap();
78
-
79
-
let stdout_handle = child
80
-
.stdout
81
-
.take()
82
-
.ok_or(HiveLibError::CommandError(CommandError::NoHandle))?;
83
-
let stderr_handle = child
84
-
.stderr
85
-
.take()
86
-
.ok_or(HiveLibError::CommandError(CommandError::NoHandle))?;
87
-
88
-
let mut joinset = JoinSet::new();
89
-
let output_mode = Arc::new(arguments.output_mode);
90
-
91
-
joinset.spawn(
92
-
handle_io(
93
-
stderr_handle,
94
-
output_mode.clone(),
95
-
error_collection.clone(),
96
-
true,
97
-
true,
98
-
)
99
-
.in_current_span(),
100
-
);
101
-
joinset.spawn(
102
-
handle_io(
103
-
stdout_handle,
104
-
output_mode.clone(),
105
-
stdout_collection.clone(),
106
-
false,
107
-
arguments.log_stdout,
108
-
)
109
-
.in_current_span(),
110
-
);
111
-
112
-
Ok(NonInteractiveChildChip {
113
-
error_collection,
114
-
stdout_collection,
115
-
child,
116
-
joinset,
117
-
original_command: arguments.command_string.as_ref().to_string(),
118
-
stdin,
119
-
})
120
-
}
121
-
122
-
impl WireCommandChip for NonInteractiveChildChip {
123
-
type ExitStatus = (ExitStatus, String);
124
-
125
-
async fn wait_till_success(mut self) -> Result<Self::ExitStatus, CommandError> {
126
-
let status = self.child.wait().await.unwrap();
127
-
let _ = self.joinset.join_all().await;
128
-
129
-
if !status.success() {
130
-
let logs = self.error_collection.lock().await.iter().rev().join("\n");
131
-
132
-
return Err(CommandError::CommandFailed {
133
-
command_ran: self.original_command,
134
-
logs,
135
-
code: match status.code() {
136
-
Some(code) => format!("code {code}"),
137
-
None => "no exit code".to_string(),
138
-
},
139
-
reason: "known-status",
140
-
});
141
-
}
142
-
143
-
let stdout = self.stdout_collection.lock().await.iter().rev().join("\n");
144
-
145
-
Ok((status, stdout))
146
-
}
147
-
148
-
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
149
-
trace!("Writing {} bytes", data.len());
150
-
self.stdin.write_all(&data).await.unwrap();
151
-
Ok(())
152
-
}
153
-
}
154
-
155
-
#[instrument(skip_all, name = "log")]
156
-
pub async fn handle_io<R>(
157
-
reader: R,
158
-
output_mode: Arc<ChildOutputMode>,
159
-
collection: Arc<Mutex<VecDeque<String>>>,
160
-
is_error: bool,
161
-
should_log: bool,
162
-
) where
163
-
R: tokio::io::AsyncRead + Unpin,
164
-
{
165
-
let mut io_reader = tokio::io::AsyncBufReadExt::lines(BufReader::new(reader));
166
-
167
-
while let Some(line) = io_reader.next_line().await.unwrap() {
168
-
let mut line = line.into_bytes();
169
-
170
-
let log = if should_log {
171
-
Some(output_mode.trace_slice(&mut line))
172
-
} else {
173
-
None
174
-
};
175
-
176
-
if !is_error {
177
-
let mut queue = collection.lock().await;
178
-
queue.push_front(String::from_utf8_lossy(&line).to_string());
179
-
} else if let Some(error_msg) = log.flatten() {
180
-
let mut queue = collection.lock().await;
181
-
queue.push_front(error_msg);
182
-
// add at most 20 message to the front, drop the rest.
183
-
queue.truncate(20);
184
-
}
185
-
}
186
-
187
-
debug!("io_handler: goodbye!");
188
-
}
189
-
190
-
fn create_sync_ssh_command(
191
-
target: &Target,
192
-
modifiers: SubCommandModifiers,
193
-
) -> Result<Command, HiveLibError> {
194
-
let mut command = Command::new("ssh");
195
-
command.args(target.create_ssh_args(modifiers, true, false)?);
196
-
command.arg(target.get_preferred_host()?.to_string());
197
-
198
-
Ok(command)
199
-
}
-102
wire/lib/src/commands/pty/input.rs
-102
wire/lib/src/commands/pty/input.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::os::fd::{AsFd, OwnedFd};
5
-
6
-
use nix::{
7
-
poll::{PollFd, PollFlags, PollTimeout, poll},
8
-
unistd::read,
9
-
};
10
-
use tracing::{Span, debug, error, instrument, trace};
11
-
12
-
use crate::{
13
-
commands::pty::{MasterWriter, THREAD_BEGAN_SIGNAL, THREAD_QUIT_SIGNAL},
14
-
errors::CommandError,
15
-
};
16
-
17
-
/// Exits on any data written to `cancel_pipe_r`
18
-
/// A pipe is used to cancel the function.
19
-
#[instrument(skip_all, level = "trace", parent = span)]
20
-
pub(super) fn watch_stdin_from_user(
21
-
cancel_pipe_r: &OwnedFd,
22
-
mut master_writer: MasterWriter,
23
-
write_pipe_r: &OwnedFd,
24
-
span: Span,
25
-
) -> Result<(), CommandError> {
26
-
const WRITER_POSITION: usize = 0;
27
-
const SIGNAL_POSITION: usize = 1;
28
-
const USER_POSITION: usize = 2;
29
-
30
-
let mut buffer = [0u8; 1024];
31
-
let stdin = std::io::stdin();
32
-
let mut cancel_pipe_buf = [0u8; 1];
33
-
34
-
let user_stdin_fd = stdin.as_fd();
35
-
let cancel_pipe_r_fd = cancel_pipe_r.as_fd();
36
-
37
-
let mut all_fds = vec![
38
-
PollFd::new(write_pipe_r.as_fd(), PollFlags::POLLIN),
39
-
PollFd::new(cancel_pipe_r.as_fd(), PollFlags::POLLIN),
40
-
PollFd::new(user_stdin_fd, PollFlags::POLLIN),
41
-
];
42
-
43
-
loop {
44
-
match poll(&mut all_fds, PollTimeout::NONE) {
45
-
Ok(0) => {} // timeout, impossible
46
-
Ok(_) => {
47
-
// The user stdin pipe can be removed
48
-
if all_fds.get(USER_POSITION).is_some()
49
-
&& let Some(events) = all_fds[USER_POSITION].revents()
50
-
&& events.contains(PollFlags::POLLIN)
51
-
{
52
-
trace!("Got stdin from user...");
53
-
let n = read(user_stdin_fd, &mut buffer).map_err(CommandError::PosixPipe)?;
54
-
master_writer
55
-
.write_all(&buffer[..n])
56
-
.map_err(CommandError::WritingMasterStdout)?;
57
-
master_writer
58
-
.flush()
59
-
.map_err(CommandError::WritingMasterStdout)?;
60
-
}
61
-
62
-
if let Some(events) = all_fds[WRITER_POSITION].revents()
63
-
&& events.contains(PollFlags::POLLIN)
64
-
{
65
-
trace!("Got stdin from writer...");
66
-
let n = read(write_pipe_r, &mut buffer).map_err(CommandError::PosixPipe)?;
67
-
master_writer
68
-
.write_all(&buffer[..n])
69
-
.map_err(CommandError::WritingMasterStdout)?;
70
-
master_writer
71
-
.flush()
72
-
.map_err(CommandError::WritingMasterStdout)?;
73
-
}
74
-
75
-
if let Some(events) = all_fds[SIGNAL_POSITION].revents()
76
-
&& events.contains(PollFlags::POLLIN)
77
-
{
78
-
let n = read(cancel_pipe_r_fd, &mut cancel_pipe_buf)
79
-
.map_err(CommandError::PosixPipe)?;
80
-
let message = &cancel_pipe_buf[..n];
81
-
82
-
trace!("Got byte from signal pipe: {message:?}");
83
-
84
-
if message == THREAD_QUIT_SIGNAL {
85
-
return Ok(());
86
-
}
87
-
88
-
if message == THREAD_BEGAN_SIGNAL {
89
-
all_fds.remove(USER_POSITION);
90
-
}
91
-
}
92
-
}
93
-
Err(e) => {
94
-
error!("Poll error: {e}");
95
-
break;
96
-
}
97
-
}
98
-
}
99
-
100
-
debug!("stdin_thread: goodbye");
101
-
Ok(())
102
-
}
-63
wire/lib/src/commands/pty/logbuffer.rs
-63
wire/lib/src/commands/pty/logbuffer.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
/// Split into its own struct to be tested nicer
5
-
pub(crate) struct LogBuffer {
6
-
buffer: Vec<u8>,
7
-
}
8
-
9
-
impl LogBuffer {
10
-
pub const fn new() -> Self {
11
-
Self { buffer: Vec::new() }
12
-
}
13
-
14
-
pub fn process_slice(&mut self, slice: &[u8]) {
15
-
self.buffer.extend_from_slice(slice);
16
-
}
17
-
18
-
pub fn next_line(&mut self) -> Option<Vec<u8>> {
19
-
let line_end = self.buffer.iter().position(|x| *x == b'\n')?;
20
-
21
-
let drained = self.buffer.drain(..line_end).collect();
22
-
self.buffer.remove(0);
23
-
Some(drained)
24
-
}
25
-
26
-
#[cfg(test)]
27
-
fn take_lines(&mut self) -> Vec<Vec<u8>> {
28
-
let mut lines = vec![];
29
-
30
-
while let Some(line) = self.next_line() {
31
-
lines.push(line);
32
-
}
33
-
34
-
lines
35
-
}
36
-
}
37
-
38
-
#[cfg(test)]
39
-
mod tests {
40
-
use super::*;
41
-
42
-
#[test]
43
-
fn test_split_line_processing() {
44
-
let mut log_buffer = LogBuffer::new();
45
-
46
-
log_buffer.process_slice(b"Writing key KeySpec { destination: \"/et");
47
-
log_buffer.process_slice(b"c/keys/buildbot.aws.key\", user: \"buildbot\", group: \"buildbot-worker\", permissions: 384, length: 32, last: false, crc: 1370815231 }, 32 bytes of data");
48
-
log_buffer.process_slice(b"\n");
49
-
log_buffer.process_slice(b"xxx");
50
-
log_buffer.process_slice(b"xx_WIRE");
51
-
log_buffer.process_slice(b"_QUIT\n");
52
-
let lines = log_buffer.take_lines();
53
-
assert_eq!(lines.len(), 2);
54
-
assert_eq!(
55
-
String::from_utf8_lossy(lines.first().unwrap()),
56
-
"Writing key KeySpec { destination: \"/etc/keys/buildbot.aws.key\", user: \"buildbot\", group: \"buildbot-worker\", permissions: 384, length: 32, last: false, crc: 1370815231 }, 32 bytes of data"
57
-
);
58
-
assert_eq!(lines.get(1), Some(&"xxxxx_WIRE_QUIT".as_bytes().to_vec()));
59
-
60
-
// taking leaves none
61
-
assert_eq!(log_buffer.take_lines().len(), 0);
62
-
}
63
-
}
-566
wire/lib/src/commands/pty/mod.rs
-566
wire/lib/src/commands/pty/mod.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use crate::commands::pty::output::{WatchStdoutArguments, handle_pty_stdout};
5
-
use crate::status::STATUS;
6
-
use aho_corasick::PatternID;
7
-
use itertools::Itertools;
8
-
use nix::sys::termios::{LocalFlags, SetArg, Termios, tcgetattr, tcsetattr};
9
-
use nix::unistd::pipe;
10
-
use nix::unistd::write as posix_write;
11
-
use portable_pty::{CommandBuilder, NativePtySystem, PtyPair, PtySize};
12
-
use rand::distr::Alphabetic;
13
-
use std::collections::VecDeque;
14
-
use std::io::stderr;
15
-
use std::sync::{LazyLock, Mutex};
16
-
use std::{
17
-
io::{Read, Write},
18
-
os::fd::{AsFd, OwnedFd},
19
-
sync::Arc,
20
-
};
21
-
use tokio::sync::{oneshot, watch};
22
-
use tracing::instrument;
23
-
use tracing::{Span, debug, trace};
24
-
25
-
use crate::commands::CommandArguments;
26
-
use crate::commands::pty::input::watch_stdin_from_user;
27
-
use crate::errors::CommandError;
28
-
use crate::{SubCommandModifiers, aquire_stdin_lock};
29
-
use crate::{
30
-
commands::{ChildOutputMode, WireCommandChip},
31
-
errors::HiveLibError,
32
-
hive::node::Target,
33
-
};
34
-
35
-
mod input;
36
-
mod logbuffer;
37
-
mod output;
38
-
39
-
type MasterWriter = Box<dyn Write + Send>;
40
-
type MasterReader = Box<dyn Read + Send>;
41
-
42
-
/// the underlying command began
43
-
const THREAD_BEGAN_SIGNAL: &[u8; 1] = b"b";
44
-
const THREAD_QUIT_SIGNAL: &[u8; 1] = b"q";
45
-
46
-
type Child = Box<dyn portable_pty::Child + Send + Sync>;
47
-
48
-
pub(crate) struct InteractiveChildChip {
49
-
child: Child,
50
-
51
-
cancel_stdin_pipe_w: OwnedFd,
52
-
write_stdin_pipe_w: OwnedFd,
53
-
54
-
stderr_collection: Arc<Mutex<VecDeque<String>>>,
55
-
stdout_collection: Arc<Mutex<VecDeque<String>>>,
56
-
57
-
original_command: String,
58
-
59
-
status_receiver: watch::Receiver<Status>,
60
-
stdout_handle: tokio::task::JoinHandle<Result<(), CommandError>>,
61
-
}
62
-
63
-
/// sets and reverts terminal options (the terminal user interaction is performed)
64
-
/// reverts data when dropped
65
-
struct StdinTermiosAttrGuard(Termios);
66
-
67
-
#[derive(Debug)]
68
-
enum Status {
69
-
Running,
70
-
Done { success: bool },
71
-
}
72
-
73
-
#[derive(Debug)]
74
-
enum SearchFindings {
75
-
None,
76
-
Started,
77
-
Terminate,
78
-
}
79
-
80
-
static STARTED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(0));
81
-
static SUCCEEDED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(1));
82
-
static FAILED_PATTERN: LazyLock<PatternID> = LazyLock::new(|| PatternID::must(2));
83
-
84
-
/// substitutes STDOUT with #$line. stdout is far less common than stderr.
85
-
const IO_SUBS: &str = "1> >(while IFS= read -r line; do echo \"#$line\"; done)";
86
-
87
-
fn create_ending_segment<S: AsRef<str>>(
88
-
arguments: &CommandArguments<'_, S>,
89
-
needles: &Needles,
90
-
) -> String {
91
-
let Needles {
92
-
succeed,
93
-
fail,
94
-
start,
95
-
} = needles;
96
-
97
-
format!(
98
-
"echo -e '{succeed}' || echo '{failed}'",
99
-
succeed = if matches!(arguments.output_mode, ChildOutputMode::Interactive) {
100
-
format!(
101
-
"{start}\\n{succeed}",
102
-
start = String::from_utf8_lossy(start),
103
-
succeed = String::from_utf8_lossy(succeed)
104
-
)
105
-
} else {
106
-
String::from_utf8_lossy(succeed).to_string()
107
-
},
108
-
failed = String::from_utf8_lossy(fail)
109
-
)
110
-
}
111
-
112
-
fn create_starting_segment<S: AsRef<str>>(
113
-
arguments: &CommandArguments<'_, S>,
114
-
start_needle: &Arc<Vec<u8>>,
115
-
) -> String {
116
-
if matches!(arguments.output_mode, ChildOutputMode::Interactive) {
117
-
String::new()
118
-
} else {
119
-
format!(
120
-
"echo '{start}' && ",
121
-
start = String::from_utf8_lossy(start_needle)
122
-
)
123
-
}
124
-
}
125
-
126
-
#[instrument(skip_all, name = "run-int", fields(elevated = %arguments.is_elevated(), mode = ?arguments.output_mode))]
127
-
pub(crate) async fn interactive_command_with_env<S: AsRef<str>>(
128
-
arguments: &CommandArguments<'_, S>,
129
-
envs: std::collections::HashMap<String, String>,
130
-
) -> Result<InteractiveChildChip, HiveLibError> {
131
-
print_authenticate_warning(arguments)?;
132
-
133
-
let needles = create_needles();
134
-
let pty_system = NativePtySystem::default();
135
-
let pty_pair = portable_pty::PtySystem::openpty(&pty_system, PtySize::default()).unwrap();
136
-
setup_master(&pty_pair)?;
137
-
138
-
let command_string = &format!(
139
-
"{starting}{command} {flags} {IO_SUBS} && {ending}",
140
-
command = arguments.command_string.as_ref(),
141
-
flags = match arguments.output_mode {
142
-
ChildOutputMode::Nix => "--log-format internal-json",
143
-
ChildOutputMode::Generic | ChildOutputMode::Interactive => "",
144
-
},
145
-
starting = create_starting_segment(arguments, &needles.start),
146
-
ending = create_ending_segment(arguments, &needles)
147
-
);
148
-
149
-
debug!("{command_string}");
150
-
151
-
let mut command = build_command(arguments, command_string)?;
152
-
153
-
// give command all env vars
154
-
for (key, value) in envs {
155
-
command.env(key, value);
156
-
}
157
-
158
-
let clobber_guard = aquire_stdin_lock().await;
159
-
let _guard = StdinTermiosAttrGuard::new().map_err(HiveLibError::CommandError)?;
160
-
let child = pty_pair
161
-
.slave
162
-
.spawn_command(command)
163
-
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
164
-
165
-
// Release any handles owned by the slave: we don't need it now
166
-
// that we've spawned the child.
167
-
drop(pty_pair.slave);
168
-
169
-
let reader = pty_pair
170
-
.master
171
-
.try_clone_reader()
172
-
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
173
-
let master_writer = pty_pair
174
-
.master
175
-
.take_writer()
176
-
.map_err(|x| HiveLibError::CommandError(CommandError::PortablePty(x)))?;
177
-
178
-
let stderr_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
179
-
let stdout_collection = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(10)));
180
-
let (began_tx, began_rx) = oneshot::channel::<()>();
181
-
let (status_sender, status_receiver) = watch::channel(Status::Running);
182
-
183
-
let stdout_handle = {
184
-
let arguments = WatchStdoutArguments {
185
-
began_tx,
186
-
reader,
187
-
needles,
188
-
output_mode: arguments.output_mode,
189
-
stderr_collection: stderr_collection.clone(),
190
-
stdout_collection: stdout_collection.clone(),
191
-
span: Span::current(),
192
-
log_stdout: arguments.log_stdout,
193
-
status_sender,
194
-
};
195
-
196
-
tokio::task::spawn_blocking(move || handle_pty_stdout(arguments))
197
-
};
198
-
199
-
let (write_stdin_pipe_r, write_stdin_pipe_w) =
200
-
pipe().map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
201
-
let (cancel_stdin_pipe_r, cancel_stdin_pipe_w) =
202
-
pipe().map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
203
-
204
-
tokio::task::spawn_blocking(move || {
205
-
watch_stdin_from_user(
206
-
&cancel_stdin_pipe_r,
207
-
master_writer,
208
-
&write_stdin_pipe_r,
209
-
Span::current(),
210
-
)
211
-
});
212
-
213
-
debug!("Setup threads");
214
-
215
-
let () = began_rx
216
-
.await
217
-
.map_err(|x| HiveLibError::CommandError(CommandError::OneshotRecvError(x)))?;
218
-
219
-
drop(clobber_guard);
220
-
221
-
if arguments.keep_stdin_open {
222
-
trace!("Sending THREAD_BEGAN_SIGNAL");
223
-
224
-
posix_write(&cancel_stdin_pipe_w, THREAD_BEGAN_SIGNAL)
225
-
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
226
-
} else {
227
-
trace!("Sending THREAD_QUIT_SIGNAL");
228
-
229
-
posix_write(&cancel_stdin_pipe_w, THREAD_QUIT_SIGNAL)
230
-
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
231
-
}
232
-
233
-
Ok(InteractiveChildChip {
234
-
child,
235
-
cancel_stdin_pipe_w,
236
-
write_stdin_pipe_w,
237
-
stderr_collection,
238
-
stdout_collection,
239
-
original_command: arguments.command_string.as_ref().to_string(),
240
-
status_receiver,
241
-
stdout_handle,
242
-
})
243
-
}
244
-
245
-
fn print_authenticate_warning<S: AsRef<str>>(
246
-
arguments: &CommandArguments<S>,
247
-
) -> Result<(), HiveLibError> {
248
-
if !arguments.is_elevated() {
249
-
return Ok(());
250
-
}
251
-
252
-
let _ = STATUS.lock().write_above_status(
253
-
&format!(
254
-
"{} | Authenticate for \"sudo {}\":\n",
255
-
arguments
256
-
.target
257
-
.map_or(Ok("localhost (!)".to_string()), |target| Ok(format!(
258
-
"{}@{}:{}",
259
-
target.user,
260
-
target.get_preferred_host()?,
261
-
target.port
262
-
)))?,
263
-
arguments.command_string.as_ref()
264
-
)
265
-
.into_bytes(),
266
-
&mut stderr(),
267
-
);
268
-
269
-
Ok(())
270
-
}
271
-
272
-
struct Needles {
273
-
succeed: Arc<Vec<u8>>,
274
-
fail: Arc<Vec<u8>>,
275
-
start: Arc<Vec<u8>>,
276
-
}
277
-
278
-
fn create_needles() -> Needles {
279
-
let tmp_prefix = rand::distr::SampleString::sample_string(&Alphabetic, &mut rand::rng(), 5);
280
-
281
-
Needles {
282
-
succeed: Arc::new(format!("{tmp_prefix}_W_Q").as_bytes().to_vec()),
283
-
fail: Arc::new(format!("{tmp_prefix}_W_F").as_bytes().to_vec()),
284
-
start: Arc::new(format!("{tmp_prefix}_W_S").as_bytes().to_vec()),
285
-
}
286
-
}
287
-
288
-
fn setup_master(pty_pair: &PtyPair) -> Result<(), HiveLibError> {
289
-
if let Some(fd) = pty_pair.master.as_raw_fd() {
290
-
// convert raw fd to a BorrowedFd
291
-
// safe as `fd` is dropped well before `pty_pair.master`
292
-
let fd = unsafe { std::os::unix::io::BorrowedFd::borrow_raw(fd) };
293
-
let mut termios =
294
-
tcgetattr(fd).map_err(|x| HiveLibError::CommandError(CommandError::TermAttrs(x)))?;
295
-
296
-
termios.local_flags &= !LocalFlags::ECHO;
297
-
// Key agent does not work well without canonical mode
298
-
termios.local_flags &= !LocalFlags::ICANON;
299
-
// Actually quit
300
-
termios.local_flags &= !LocalFlags::ISIG;
301
-
302
-
tcsetattr(fd, SetArg::TCSANOW, &termios)
303
-
.map_err(|x| HiveLibError::CommandError(CommandError::TermAttrs(x)))?;
304
-
}
305
-
306
-
Ok(())
307
-
}
308
-
309
-
fn build_command<S: AsRef<str>>(
310
-
arguments: &CommandArguments<'_, S>,
311
-
command_string: &String,
312
-
) -> Result<CommandBuilder, HiveLibError> {
313
-
let mut command = if let Some(target) = arguments.target {
314
-
let mut command = create_int_ssh_command(target, arguments.modifiers)?;
315
-
316
-
// force ssh to use our pseudo terminal
317
-
command.arg("-tt");
318
-
319
-
command
320
-
} else {
321
-
let mut command = portable_pty::CommandBuilder::new("sh");
322
-
323
-
command.arg("-c");
324
-
325
-
command
326
-
};
327
-
328
-
if arguments.is_elevated() {
329
-
command.arg(format!("sudo -u root -- sh -c '{command_string}'"));
330
-
} else {
331
-
command.arg(command_string);
332
-
}
333
-
334
-
Ok(command)
335
-
}
336
-
337
-
impl WireCommandChip for InteractiveChildChip {
338
-
type ExitStatus = (portable_pty::ExitStatus, String);
339
-
340
-
#[instrument(skip_all)]
341
-
async fn wait_till_success(mut self) -> Result<Self::ExitStatus, CommandError> {
342
-
drop(self.write_stdin_pipe_w);
343
-
344
-
let exit_status = tokio::task::spawn_blocking(move || self.child.wait())
345
-
.await
346
-
.map_err(CommandError::JoinError)?
347
-
.map_err(CommandError::WaitForStatus)?;
348
-
349
-
debug!("exit_status: {exit_status:?}");
350
-
351
-
self.stdout_handle
352
-
.await
353
-
.map_err(|_| CommandError::ThreadPanic)??;
354
-
355
-
let status = self
356
-
.status_receiver
357
-
.wait_for(|value| matches!(value, Status::Done { .. }))
358
-
.await
359
-
.unwrap();
360
-
361
-
let _ = posix_write(&self.cancel_stdin_pipe_w, THREAD_QUIT_SIGNAL);
362
-
363
-
if let Status::Done { success: true } = *status {
364
-
let logs = self
365
-
.stdout_collection
366
-
.lock()
367
-
.unwrap()
368
-
.iter()
369
-
.rev()
370
-
.map(|x| x.trim())
371
-
.join("\n");
372
-
373
-
return Ok((exit_status, logs));
374
-
}
375
-
376
-
debug!("child did not succeed");
377
-
378
-
let logs = self
379
-
.stderr_collection
380
-
.lock()
381
-
.unwrap()
382
-
.iter()
383
-
.rev()
384
-
.join("\n");
385
-
386
-
Err(CommandError::CommandFailed {
387
-
command_ran: self.original_command,
388
-
logs,
389
-
code: format!("code {}", exit_status.exit_code()),
390
-
reason: match *status {
391
-
Status::Done { .. } => "marked-unsuccessful",
392
-
Status::Running => "child-crashed-before-succeeding",
393
-
},
394
-
})
395
-
}
396
-
397
-
async fn write_stdin(&mut self, data: Vec<u8>) -> Result<(), HiveLibError> {
398
-
trace!("Writing {} bytes to stdin", data.len());
399
-
400
-
posix_write(&self.write_stdin_pipe_w, &data)
401
-
.map_err(|x| HiveLibError::CommandError(CommandError::PosixPipe(x)))?;
402
-
403
-
Ok(())
404
-
}
405
-
}
406
-
407
-
impl StdinTermiosAttrGuard {
408
-
fn new() -> Result<Self, CommandError> {
409
-
let stdin = std::io::stdin();
410
-
let stdin_fd = stdin.as_fd();
411
-
412
-
let mut termios = tcgetattr(stdin_fd).map_err(CommandError::TermAttrs)?;
413
-
let original_termios = termios.clone();
414
-
415
-
termios.local_flags &= !(LocalFlags::ECHO | LocalFlags::ICANON);
416
-
tcsetattr(stdin_fd, SetArg::TCSANOW, &termios).map_err(CommandError::TermAttrs)?;
417
-
418
-
Ok(StdinTermiosAttrGuard(original_termios))
419
-
}
420
-
}
421
-
422
-
impl Drop for StdinTermiosAttrGuard {
423
-
fn drop(&mut self) {
424
-
let stdin = std::io::stdin();
425
-
let stdin_fd = stdin.as_fd();
426
-
427
-
let _ = tcsetattr(stdin_fd, SetArg::TCSANOW, &self.0);
428
-
}
429
-
}
430
-
431
-
fn create_int_ssh_command(
432
-
target: &Target,
433
-
modifiers: SubCommandModifiers,
434
-
) -> Result<portable_pty::CommandBuilder, HiveLibError> {
435
-
let mut command = portable_pty::CommandBuilder::new("ssh");
436
-
command.args(target.create_ssh_args(modifiers, false, false)?);
437
-
command.arg(target.get_preferred_host()?.to_string());
438
-
Ok(command)
439
-
}
440
-
441
-
#[cfg(test)]
442
-
mod tests {
443
-
use aho_corasick::AhoCorasick;
444
-
use tokio::sync::oneshot::error::TryRecvError;
445
-
446
-
use crate::commands::pty::output::handle_rawmode_data;
447
-
448
-
use super::*;
449
-
use std::assert_matches::assert_matches;
450
-
451
-
#[test]
452
-
fn test_rawmode_data() {
453
-
let aho_corasick = AhoCorasick::builder()
454
-
.ascii_case_insensitive(false)
455
-
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
456
-
.build(["START_NEEDLE", "SUCCEEDED_NEEDLE", "FAILED_NEEDLE"])
457
-
.unwrap();
458
-
let mut stderr = vec![];
459
-
let (began_tx, mut began_rx) = oneshot::channel::<()>();
460
-
let mut began_tx = Some(began_tx);
461
-
let (status_sender, _) = watch::channel(Status::Running);
462
-
463
-
// each "Bla" is 4 bytes.
464
-
let buffer = "bla bla bla START_NEEDLE bla bla bla".as_bytes();
465
-
let mut raw_mode_buffer = vec![];
466
-
467
-
// handle 1 "bla"
468
-
assert_matches!(
469
-
handle_rawmode_data(
470
-
&mut stderr,
471
-
buffer,
472
-
4,
473
-
&mut raw_mode_buffer,
474
-
&aho_corasick,
475
-
&status_sender,
476
-
&mut began_tx
477
-
),
478
-
Ok(SearchFindings::None)
479
-
);
480
-
assert_matches!(began_rx.try_recv(), Err(TryRecvError::Empty));
481
-
assert!(began_tx.is_some());
482
-
assert_eq!(raw_mode_buffer, b"bla ");
483
-
assert_matches!(*status_sender.borrow(), Status::Running);
484
-
485
-
let buffer = &buffer[4..];
486
-
487
-
// handle 2 "bla"'s and half a "START_NEEDLE"
488
-
let n = 4 + 4 + 6;
489
-
assert_matches!(
490
-
handle_rawmode_data(
491
-
&mut stderr,
492
-
buffer,
493
-
n,
494
-
&mut raw_mode_buffer,
495
-
&aho_corasick,
496
-
&status_sender,
497
-
&mut began_tx
498
-
),
499
-
Ok(SearchFindings::None)
500
-
);
501
-
assert_matches!(began_rx.try_recv(), Err(TryRecvError::Empty));
502
-
assert!(began_tx.is_some());
503
-
assert_matches!(*status_sender.borrow(), Status::Running);
504
-
assert_eq!(raw_mode_buffer, b"bla bla bla START_");
505
-
506
-
let buffer = &buffer[n..];
507
-
508
-
// handle rest of the data
509
-
let n = buffer.len();
510
-
assert_matches!(
511
-
handle_rawmode_data(
512
-
&mut stderr,
513
-
buffer,
514
-
n,
515
-
&mut raw_mode_buffer,
516
-
&aho_corasick,
517
-
&status_sender,
518
-
&mut began_tx
519
-
),
520
-
Ok(SearchFindings::Started)
521
-
);
522
-
assert_matches!(began_rx.try_recv(), Ok(()));
523
-
assert_matches!(began_tx, None);
524
-
assert_eq!(raw_mode_buffer, b"bla bla bla START_NEEDLE bla bla bla");
525
-
assert_matches!(*status_sender.borrow(), Status::Running);
526
-
527
-
// test failed needle
528
-
let buffer = "bla FAILED_NEEDLE bla".as_bytes();
529
-
let mut raw_mode_buffer = vec![];
530
-
531
-
let n = buffer.len();
532
-
assert_matches!(
533
-
handle_rawmode_data(
534
-
&mut stderr,
535
-
buffer,
536
-
n,
537
-
&mut raw_mode_buffer,
538
-
&aho_corasick,
539
-
&status_sender,
540
-
&mut began_tx
541
-
),
542
-
Ok(SearchFindings::Terminate)
543
-
);
544
-
assert_matches!(*status_sender.borrow(), Status::Done { success: false });
545
-
546
-
// test succeed needle
547
-
let buffer = "bla SUCCEEDED_NEEDLE bla".as_bytes();
548
-
let mut raw_mode_buffer = vec![];
549
-
let (status_sender, _) = watch::channel(Status::Running);
550
-
551
-
let n = buffer.len();
552
-
assert_matches!(
553
-
handle_rawmode_data(
554
-
&mut stderr,
555
-
buffer,
556
-
n,
557
-
&mut raw_mode_buffer,
558
-
&aho_corasick,
559
-
&status_sender,
560
-
&mut began_tx
561
-
),
562
-
Ok(SearchFindings::Terminate)
563
-
);
564
-
assert_matches!(*status_sender.borrow(), Status::Done { success: true });
565
-
}
566
-
}
-262
wire/lib/src/commands/pty/output.rs
-262
wire/lib/src/commands/pty/output.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use crate::{
5
-
commands::{
6
-
ChildOutputMode,
7
-
pty::{
8
-
FAILED_PATTERN, Needles, STARTED_PATTERN, SUCCEEDED_PATTERN, SearchFindings, Status,
9
-
logbuffer::LogBuffer,
10
-
},
11
-
},
12
-
errors::CommandError,
13
-
};
14
-
use aho_corasick::AhoCorasick;
15
-
use std::{
16
-
collections::VecDeque,
17
-
io::Write,
18
-
sync::{Arc, Mutex},
19
-
};
20
-
use tokio::sync::{oneshot, watch};
21
-
use tracing::{Span, debug, instrument};
22
-
23
-
pub(super) struct WatchStdoutArguments {
24
-
pub began_tx: oneshot::Sender<()>,
25
-
pub reader: super::MasterReader,
26
-
pub needles: Needles,
27
-
pub output_mode: ChildOutputMode,
28
-
pub stderr_collection: Arc<Mutex<VecDeque<String>>>,
29
-
pub stdout_collection: Arc<Mutex<VecDeque<String>>>,
30
-
pub status_sender: watch::Sender<Status>,
31
-
pub span: Span,
32
-
pub log_stdout: bool,
33
-
}
34
-
35
-
/// Handles data from the PTY, and logs or prompts the user depending on the state
36
-
/// of the command.
37
-
///
38
-
/// Emits a message on the `began_tx` when the command is considered started.
39
-
///
40
-
/// Records stderr and stdout when it is considered notable (all stdout, last few stderr messages)
41
-
#[instrument(skip_all, name = "log", parent = arguments.span)]
42
-
pub(super) fn handle_pty_stdout(arguments: WatchStdoutArguments) -> Result<(), CommandError> {
43
-
let WatchStdoutArguments {
44
-
began_tx,
45
-
mut reader,
46
-
needles,
47
-
output_mode,
48
-
stdout_collection,
49
-
stderr_collection,
50
-
status_sender,
51
-
log_stdout,
52
-
..
53
-
} = arguments;
54
-
55
-
let aho_corasick = AhoCorasick::builder()
56
-
.ascii_case_insensitive(false)
57
-
.match_kind(aho_corasick::MatchKind::LeftmostFirst)
58
-
.build([
59
-
needles.start.as_ref(),
60
-
needles.succeed.as_ref(),
61
-
needles.fail.as_ref(),
62
-
])
63
-
.unwrap();
64
-
65
-
let mut buffer = [0u8; 1024];
66
-
let mut stderr = std::io::stderr();
67
-
let mut began = false;
68
-
let mut log_buffer = LogBuffer::new();
69
-
let mut raw_mode_buffer = Vec::new();
70
-
let mut belled = false;
71
-
let mut began_tx = Some(began_tx);
72
-
73
-
'outer: loop {
74
-
match reader.read(&mut buffer) {
75
-
Ok(0) => break 'outer,
76
-
Ok(n) => {
77
-
if !began {
78
-
let findings = handle_rawmode_data(
79
-
&mut stderr,
80
-
&buffer,
81
-
n,
82
-
&mut raw_mode_buffer,
83
-
&aho_corasick,
84
-
&status_sender,
85
-
&mut began_tx,
86
-
)?;
87
-
88
-
match findings {
89
-
SearchFindings::Terminate => break 'outer,
90
-
SearchFindings::Started => {
91
-
began = true;
92
-
continue;
93
-
}
94
-
SearchFindings::None => {}
95
-
}
96
-
97
-
if belled {
98
-
continue;
99
-
}
100
-
101
-
stderr
102
-
.write(b"\x07")
103
-
.map_err(CommandError::WritingClientStderr)?;
104
-
stderr.flush().map_err(CommandError::WritingClientStderr)?;
105
-
106
-
belled = true;
107
-
108
-
continue;
109
-
}
110
-
111
-
log_buffer.process_slice(&buffer[..n]);
112
-
113
-
while let Some(mut line) = log_buffer.next_line() {
114
-
let findings =
115
-
search_string(&aho_corasick, &line, &status_sender, &mut began_tx);
116
-
117
-
match findings {
118
-
SearchFindings::Terminate => break 'outer,
119
-
SearchFindings::Started => {
120
-
began = true;
121
-
continue;
122
-
}
123
-
SearchFindings::None => {}
124
-
}
125
-
126
-
handle_normal_data(
127
-
&stderr_collection,
128
-
&stdout_collection,
129
-
&mut line,
130
-
log_stdout,
131
-
output_mode,
132
-
);
133
-
}
134
-
}
135
-
Err(e) => {
136
-
eprintln!("Error reading from PTY: {e}");
137
-
break;
138
-
}
139
-
}
140
-
}
141
-
142
-
began_tx.map(|began_tx| began_tx.send(()));
143
-
144
-
// failsafe if there were errors or the reader stopped
145
-
if matches!(*status_sender.borrow(), Status::Running) {
146
-
status_sender.send_replace(Status::Done { success: false });
147
-
}
148
-
149
-
debug!("stdout: goodbye");
150
-
151
-
Ok(())
152
-
}
153
-
154
-
/// handles raw data, prints to stderr when a prompt is detected
155
-
pub(super) fn handle_rawmode_data<W: std::io::Write>(
156
-
stderr: &mut W,
157
-
buffer: &[u8],
158
-
n: usize,
159
-
raw_mode_buffer: &mut Vec<u8>,
160
-
aho_corasick: &AhoCorasick,
161
-
status_sender: &watch::Sender<Status>,
162
-
began_tx: &mut Option<oneshot::Sender<()>>,
163
-
) -> Result<SearchFindings, CommandError> {
164
-
raw_mode_buffer.extend_from_slice(&buffer[..n]);
165
-
166
-
let findings = search_string(aho_corasick, raw_mode_buffer, status_sender, began_tx);
167
-
168
-
if matches!(
169
-
findings,
170
-
SearchFindings::Started | SearchFindings::Terminate
171
-
) {
172
-
return Ok(findings);
173
-
}
174
-
175
-
stderr
176
-
.write_all(&buffer[..n])
177
-
.map_err(CommandError::WritingClientStderr)?;
178
-
179
-
stderr.flush().map_err(CommandError::WritingClientStderr)?;
180
-
181
-
Ok(findings)
182
-
}
183
-
184
-
/// handles data when the command is considered "started", logs and records errors as appropriate
185
-
fn handle_normal_data(
186
-
stderr_collection: &Arc<Mutex<VecDeque<String>>>,
187
-
stdout_collection: &Arc<Mutex<VecDeque<String>>>,
188
-
line: &mut [u8],
189
-
log_stdout: bool,
190
-
output_mode: ChildOutputMode,
191
-
) {
192
-
if line.starts_with(b"#") {
193
-
let stripped = &mut line[1..];
194
-
195
-
if log_stdout {
196
-
output_mode.trace_slice(stripped);
197
-
}
198
-
199
-
let mut queue = stdout_collection.lock().unwrap();
200
-
queue.push_front(String::from_utf8_lossy(stripped).to_string());
201
-
return;
202
-
}
203
-
204
-
let log = output_mode.trace_slice(line);
205
-
206
-
if let Some(error_msg) = log {
207
-
let mut queue = stderr_collection.lock().unwrap();
208
-
209
-
// add at most 20 message to the front, drop the rest.
210
-
queue.push_front(error_msg);
211
-
queue.truncate(20);
212
-
}
213
-
}
214
-
215
-
/// returns true if the command is considered stopped
216
-
fn search_string(
217
-
aho_corasick: &AhoCorasick,
218
-
haystack: &[u8],
219
-
status_sender: &watch::Sender<Status>,
220
-
began_tx: &mut Option<oneshot::Sender<()>>,
221
-
) -> SearchFindings {
222
-
let searched = aho_corasick
223
-
.find_iter(haystack)
224
-
.map(|x| x.pattern())
225
-
.collect::<Vec<_>>();
226
-
227
-
let started = if searched.contains(&STARTED_PATTERN) {
228
-
debug!("start needle was found, switching mode...");
229
-
if let Some(began_tx) = began_tx.take() {
230
-
let _ = began_tx.send(());
231
-
}
232
-
true
233
-
} else {
234
-
false
235
-
};
236
-
237
-
let succeeded = if searched.contains(&SUCCEEDED_PATTERN) {
238
-
debug!("succeed needle was found, marking child as succeeding.");
239
-
status_sender.send_replace(Status::Done { success: true });
240
-
true
241
-
} else {
242
-
false
243
-
};
244
-
245
-
let failed = if searched.contains(&FAILED_PATTERN) {
246
-
debug!("failed needle was found, elevated child did not succeed.");
247
-
status_sender.send_replace(Status::Done { success: false });
248
-
true
249
-
} else {
250
-
false
251
-
};
252
-
253
-
if succeeded || failed {
254
-
return SearchFindings::Terminate;
255
-
}
256
-
257
-
if started {
258
-
return SearchFindings::Started;
259
-
}
260
-
261
-
SearchFindings::None
262
-
}
-383
wire/lib/src/errors.rs
-383
wire/lib/src/errors.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#![allow(unused_assignments)]
5
-
6
-
use std::{num::ParseIntError, path::PathBuf, process::ExitStatus, sync::mpsc::RecvError};
7
-
8
-
use miette::{Diagnostic, SourceSpan};
9
-
use nix_compat::flakeref::{FlakeRef, FlakeRefError};
10
-
use thiserror::Error;
11
-
use tokio::task::JoinError;
12
-
13
-
use crate::hive::node::{Name, SwitchToConfigurationGoal};
14
-
15
-
#[cfg(debug_assertions)]
16
-
const DOCS_URL: &str = "http://localhost:5173/reference/errors.html";
17
-
#[cfg(not(debug_assertions))]
18
-
const DOCS_URL: &str = "https://wire.althaea.zone/reference/errors.html";
19
-
20
-
#[derive(Debug, Diagnostic, Error)]
21
-
pub enum KeyError {
22
-
#[diagnostic(
23
-
code(wire::key::File),
24
-
url("{DOCS_URL}#{}", self.code().unwrap())
25
-
)]
26
-
#[error("error reading file")]
27
-
File(#[source] std::io::Error),
28
-
29
-
#[diagnostic(
30
-
code(wire::key::SpawningCommand),
31
-
help("Ensure wire has the correct $PATH for this command"),
32
-
url("{DOCS_URL}#{}", self.code().unwrap())
33
-
)]
34
-
#[error("error spawning key command")]
35
-
CommandSpawnError {
36
-
#[source]
37
-
error: std::io::Error,
38
-
39
-
#[source_code]
40
-
command: String,
41
-
42
-
#[label(primary, "Program ran")]
43
-
command_span: Option<SourceSpan>,
44
-
},
45
-
46
-
#[diagnostic(
47
-
code(wire::key::Resolving),
48
-
url("{DOCS_URL}#{}", self.code().unwrap())
49
-
)]
50
-
#[error("Error resolving key command child process")]
51
-
CommandResolveError {
52
-
#[source]
53
-
error: std::io::Error,
54
-
55
-
#[source_code]
56
-
command: String,
57
-
},
58
-
59
-
#[diagnostic(
60
-
code(wire::key::CommandExit),
61
-
url("{DOCS_URL}#{}", self.code().unwrap())
62
-
)]
63
-
#[error("key command failed with status {}: {}", .0,.1)]
64
-
CommandError(ExitStatus, String),
65
-
66
-
#[diagnostic(
67
-
code(wire::key::Empty),
68
-
url("{DOCS_URL}#{}", self.code().unwrap())
69
-
)]
70
-
#[error("Command list empty")]
71
-
Empty,
72
-
73
-
#[diagnostic(
74
-
code(wire::key::ParseKeyPermissions),
75
-
help("Refer to the documentation for the format of key file permissions."),
76
-
url("{DOCS_URL}#{}", self.code().unwrap())
77
-
)]
78
-
#[error("Failed to parse key permissions")]
79
-
ParseKeyPermissions(#[source] ParseIntError),
80
-
}
81
-
82
-
#[derive(Debug, Diagnostic, Error)]
83
-
pub enum ActivationError {
84
-
#[diagnostic(
85
-
code(wire::activation::SwitchToConfiguration),
86
-
url("{DOCS_URL}#{}", self.code().unwrap())
87
-
)]
88
-
#[error("failed to run switch-to-configuration {0} on node {1}")]
89
-
SwitchToConfigurationError(SwitchToConfigurationGoal, Name, #[source] CommandError),
90
-
91
-
#[diagnostic(
92
-
code(wire::activation::Heartbeat),
93
-
url("{DOCS_URL}#{}", self.code().unwrap())
94
-
)]
95
-
#[error("failed to touch /var/lib/wire-rollback/heartbeat on node {name}")]
96
-
FailedHeartbeatError {
97
-
name: Name,
98
-
#[source]
99
-
activation_failure: CommandError,
100
-
101
-
#[related]
102
-
related_errors: Vec<CommandError>,
103
-
},
104
-
}
105
-
106
-
#[derive(Debug, Diagnostic, Error)]
107
-
pub enum NetworkError {
108
-
#[diagnostic(
109
-
code(wire::network::HostUnreachable),
110
-
help(
111
-
"If you failed due to a fault in DNS, note that a node can have multiple targets defined."
112
-
),
113
-
url("{DOCS_URL}#{}", self.code().unwrap())
114
-
)]
115
-
#[error("Cannot reach host {host}")]
116
-
HostUnreachable {
117
-
host: String,
118
-
#[source]
119
-
source: CommandError,
120
-
},
121
-
122
-
#[diagnostic(
123
-
code(wire::network::HostUnreachableAfterReboot),
124
-
url("{DOCS_URL}#{}", self.code().unwrap())
125
-
)]
126
-
#[error("Failed to get regain connection to {0} after activation.")]
127
-
HostUnreachableAfterReboot(String),
128
-
129
-
#[diagnostic(
130
-
code(wire::network::HostsExhausted),
131
-
url("{DOCS_URL}#{}", self.code().unwrap())
132
-
)]
133
-
#[error("Ran out of contactable hosts")]
134
-
HostsExhausted,
135
-
}
136
-
137
-
#[derive(Debug, Diagnostic, Error)]
138
-
pub enum HiveInitialisationError {
139
-
#[diagnostic(
140
-
code(wire::hive_init::NoHiveFound),
141
-
help(
142
-
"Double check the path is correct. You can adjust the hive path with `--path` when the hive lies outside of the CWD."
143
-
),
144
-
url("{DOCS_URL}#{}", self.code().unwrap())
145
-
)]
146
-
#[error("No hive could be found in {}", .0.display())]
147
-
NoHiveFound(PathBuf),
148
-
149
-
#[diagnostic(
150
-
code(wire::hive_init::Parse),
151
-
help("If you cannot resolve this problem, please create an issue."),
152
-
url("{DOCS_URL}#{}", self.code().unwrap())
153
-
)]
154
-
#[error("Failed to parse internal wire json.")]
155
-
ParseEvaluateError(#[source] serde_json::Error),
156
-
157
-
#[diagnostic(
158
-
code(wire::hive_init::ParsePrefetch),
159
-
help("please create an issue."),
160
-
url("{DOCS_URL}#{}", self.code().unwrap())
161
-
)]
162
-
#[error("Failed to parse `nix flake prefetch --json`.")]
163
-
ParsePrefetchError(#[source] serde_json::Error),
164
-
165
-
#[diagnostic(
166
-
code(wire::hive_init::NodeDoesNotExist),
167
-
help("Please create an issue!"),
168
-
url("{DOCS_URL}#{}", self.code().unwrap())
169
-
)]
170
-
#[error("node {0} not exist in hive")]
171
-
NodeDoesNotExist(String),
172
-
}
173
-
174
-
#[derive(Debug, Diagnostic, Error)]
175
-
pub enum HiveLocationError {
176
-
#[diagnostic(
177
-
code(wire::hive_location::MalformedPath),
178
-
url("{DOCS_URL}#{}", self.code().unwrap())
179
-
)]
180
-
#[error("Path was malformed: {}", .0.display())]
181
-
MalformedPath(PathBuf),
182
-
183
-
#[diagnostic(
184
-
code(wire::hive_location::Malformed),
185
-
url("{DOCS_URL}#{}", self.code().unwrap())
186
-
)]
187
-
#[error("--path was malformed")]
188
-
Malformed(#[source] FlakeRefError),
189
-
190
-
#[diagnostic(
191
-
code(wire::hive_location::TypeUnsupported),
192
-
url("{DOCS_URL}#{}", self.code().unwrap())
193
-
)]
194
-
#[error("The flakref had an unsupported type: {:#?}", .0)]
195
-
TypeUnsupported(Box<FlakeRef>),
196
-
}
197
-
198
-
#[derive(Debug, Diagnostic, Error)]
199
-
pub enum CommandError {
200
-
#[diagnostic(
201
-
code(wire::command::TermAttrs),
202
-
url("{DOCS_URL}#{}", self.code().unwrap())
203
-
)]
204
-
#[error("Failed to set PTY attrs")]
205
-
TermAttrs(#[source] nix::errno::Errno),
206
-
207
-
#[diagnostic(
208
-
code(wire::command::PosixPipe),
209
-
url("{DOCS_URL}#{}", self.code().unwrap())
210
-
)]
211
-
#[error("There was an error in regards to a pipe")]
212
-
PosixPipe(#[source] nix::errno::Errno),
213
-
214
-
/// Error wrapped around `portable_pty`'s anyhow
215
-
/// errors
216
-
#[diagnostic(
217
-
code(wire::command::PortablePty),
218
-
url("{DOCS_URL}#{}", self.code().unwrap())
219
-
)]
220
-
#[error("There was an error from the portable_pty crate")]
221
-
PortablePty(#[source] anyhow::Error),
222
-
223
-
#[diagnostic(
224
-
code(wire::command::Joining),
225
-
url("{DOCS_URL}#{}", self.code().unwrap())
226
-
)]
227
-
#[error("Failed to join on some tokio task")]
228
-
JoinError(#[source] JoinError),
229
-
230
-
#[diagnostic(
231
-
code(wire::command::WaitForStatus),
232
-
url("{DOCS_URL}#{}", self.code().unwrap())
233
-
)]
234
-
#[error("Failed to wait for the child's status")]
235
-
WaitForStatus(#[source] std::io::Error),
236
-
237
-
#[diagnostic(
238
-
code(wire::detached::NoHandle),
239
-
help("This should never happen, please create an issue!"),
240
-
url("{DOCS_URL}#{}", self.code().unwrap())
241
-
)]
242
-
#[error("There was no handle to child io")]
243
-
NoHandle,
244
-
245
-
#[diagnostic(
246
-
code(wire::command::WritingClientStdout),
247
-
url("{DOCS_URL}#{}", self.code().unwrap())
248
-
)]
249
-
#[error("Failed to write to client stderr.")]
250
-
WritingClientStderr(#[source] std::io::Error),
251
-
252
-
#[diagnostic(
253
-
code(wire::command::WritingMasterStdin),
254
-
url("{DOCS_URL}#{}", self.code().unwrap())
255
-
)]
256
-
#[error("Failed to write to PTY master stdout.")]
257
-
WritingMasterStdout(#[source] std::io::Error),
258
-
259
-
#[diagnostic(
260
-
code(wire::command::Recv),
261
-
url("{DOCS_URL}#{}", self.code().unwrap()),
262
-
help("please create an issue!"),
263
-
)]
264
-
#[error("Failed to receive a message from the begin channel")]
265
-
RecvError(#[source] RecvError),
266
-
267
-
#[diagnostic(
268
-
code(wire::command::ThreadPanic),
269
-
url("{DOCS_URL}#{}", self.code().unwrap()),
270
-
help("please create an issue!"),
271
-
)]
272
-
#[error("Thread panicked")]
273
-
ThreadPanic,
274
-
275
-
#[diagnostic(
276
-
code(wire::command::CommandFailed),
277
-
url("{DOCS_URL}#{}", self.code().unwrap()),
278
-
help("`nix` commands are filtered, run with -vvv to view all"),
279
-
)]
280
-
#[error("{command_ran} failed ({reason}) with {code} (last 20 lines):\n{logs}")]
281
-
CommandFailed {
282
-
command_ran: String,
283
-
logs: String,
284
-
code: String,
285
-
reason: &'static str,
286
-
},
287
-
288
-
#[diagnostic(
289
-
code(wire::command::RuntimeDirectory),
290
-
url("{DOCS_URL}#{}", self.code().unwrap())
291
-
)]
292
-
#[error("error creating $XDG_RUNTIME_DIR/wire")]
293
-
RuntimeDirectory(#[source] std::io::Error),
294
-
295
-
#[diagnostic(
296
-
code(wire::command::RuntimeDirectoryMissing),
297
-
url("{DOCS_URL}#{}", self.code().unwrap())
298
-
)]
299
-
#[error("$XDG_RUNTIME_DIR could not be used.")]
300
-
RuntimeDirectoryMissing(#[source] std::env::VarError),
301
-
302
-
#[diagnostic(
303
-
code(wire::command::OneshotRecvError),
304
-
url("{DOCS_URL}#{}", self.code().unwrap())
305
-
)]
306
-
#[error("Error waiting for begin message")]
307
-
OneshotRecvError(#[source] tokio::sync::oneshot::error::RecvError),
308
-
}
309
-
310
-
#[derive(Debug, Diagnostic, Error)]
311
-
pub enum HiveLibError {
312
-
#[error(transparent)]
313
-
#[diagnostic(transparent)]
314
-
HiveInitialisationError(HiveInitialisationError),
315
-
316
-
#[error(transparent)]
317
-
#[diagnostic(transparent)]
318
-
NetworkError(NetworkError),
319
-
320
-
#[error(transparent)]
321
-
#[diagnostic(transparent)]
322
-
ActivationError(ActivationError),
323
-
324
-
#[error(transparent)]
325
-
#[diagnostic(transparent)]
326
-
CommandError(CommandError),
327
-
328
-
#[error(transparent)]
329
-
#[diagnostic(transparent)]
330
-
HiveLocationError(HiveLocationError),
331
-
332
-
#[error("Failed to apply key {}", .0)]
333
-
KeyError(
334
-
String,
335
-
#[source]
336
-
#[diagnostic_source]
337
-
KeyError,
338
-
),
339
-
340
-
#[diagnostic(
341
-
code(wire::BuildNode),
342
-
url("{DOCS_URL}#{}", self.code().unwrap())
343
-
)]
344
-
#[error("failed to build node {name}")]
345
-
NixBuildError {
346
-
name: Name,
347
-
#[source]
348
-
source: CommandError,
349
-
},
350
-
351
-
#[diagnostic(
352
-
code(wire::CopyPath),
353
-
url("{DOCS_URL}#{}", self.code().unwrap())
354
-
)]
355
-
#[error("failed to copy path {path} to node {name}")]
356
-
NixCopyError {
357
-
name: Name,
358
-
path: String,
359
-
#[source]
360
-
error: Box<CommandError>,
361
-
#[help]
362
-
help: Option<Box<String>>,
363
-
},
364
-
365
-
#[diagnostic(code(wire::Evaluate))]
366
-
#[error("failed to evaluate `{attribute}` from the context of a hive.")]
367
-
NixEvalError {
368
-
attribute: String,
369
-
370
-
#[source]
371
-
source: CommandError,
372
-
373
-
#[help]
374
-
help: Option<Box<String>>,
375
-
},
376
-
377
-
#[diagnostic(
378
-
code(wire::Encoding),
379
-
url("{DOCS_URL}#{}", self.code().unwrap())
380
-
)]
381
-
#[error("error encoding length delimited data")]
382
-
Encoding(#[source] std::io::Error),
383
-
}
-467
wire/lib/src/hive/mod.rs
-467
wire/lib/src/hive/mod.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use itertools::Itertools;
5
-
use nix_compat::flakeref::FlakeRef;
6
-
use node::{Name, Node};
7
-
use owo_colors::{OwoColorize, Stream};
8
-
use serde::de::Error;
9
-
use serde::{Deserialize, Deserializer, Serialize};
10
-
use std::collections::HashMap;
11
-
use std::collections::hash_map::OccupiedEntry;
12
-
use std::ffi::OsStr;
13
-
use std::fmt::Display;
14
-
use std::fs;
15
-
use std::path::PathBuf;
16
-
use std::str::FromStr;
17
-
use std::sync::Arc;
18
-
use tracing::{debug, info, instrument};
19
-
20
-
use crate::cache::InspectionCache;
21
-
use crate::commands::common::evaluate_hive_attribute;
22
-
use crate::commands::{CommandArguments, Either, WireCommandChip, run_command};
23
-
use crate::errors::{HiveInitialisationError, HiveLocationError};
24
-
use crate::{EvalGoal, HiveLibError, SubCommandModifiers};
25
-
pub mod node;
26
-
pub mod steps;
27
-
28
-
#[derive(Serialize, Deserialize, Debug, PartialEq)]
29
-
#[serde(deny_unknown_fields)]
30
-
pub struct Hive {
31
-
pub nodes: HashMap<Name, Node>,
32
-
33
-
#[serde(deserialize_with = "check_schema_version", rename = "_schema")]
34
-
pub schema: u32,
35
-
}
36
-
37
-
pub enum Action<'a> {
38
-
Inspect,
39
-
EvaluateNode(OccupiedEntry<'a, String, Node>),
40
-
}
41
-
42
-
fn check_schema_version<'de, D: Deserializer<'de>>(d: D) -> Result<u32, D::Error> {
43
-
let version = u32::deserialize(d)?;
44
-
if version != Hive::SCHEMA_VERSION {
45
-
return Err(D::Error::custom(
46
-
"Version mismatch for Hive. Please ensure the binary and your wire input match!",
47
-
));
48
-
}
49
-
Ok(version)
50
-
}
51
-
52
-
impl Hive {
53
-
pub const SCHEMA_VERSION: u32 = 1;
54
-
55
-
#[instrument(skip_all, name = "eval_hive")]
56
-
pub async fn new_from_path(
57
-
location: &HiveLocation,
58
-
cache: Option<InspectionCache>,
59
-
modifiers: SubCommandModifiers,
60
-
) -> Result<Hive, HiveLibError> {
61
-
info!("evaluating hive {location:?}");
62
-
63
-
if let Some(ref cache) = cache
64
-
&& let HiveLocation::Flake { prefetch, .. } = location
65
-
&& let Some(hive) = cache.get_hive(prefetch).await
66
-
{
67
-
return Ok(hive);
68
-
}
69
-
70
-
let output = evaluate_hive_attribute(location, &EvalGoal::Inspect, modifiers).await?;
71
-
72
-
let hive: Hive = serde_json::from_str(&output).map_err(|err| {
73
-
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParseEvaluateError(err))
74
-
})?;
75
-
76
-
if let Some(cache) = cache
77
-
&& let HiveLocation::Flake { prefetch, .. } = location
78
-
{
79
-
cache.store_hive(prefetch, &output).await;
80
-
}
81
-
82
-
Ok(hive)
83
-
}
84
-
85
-
/// # Errors
86
-
///
87
-
/// Returns an error if a node in nodes does not exist in the hive.
88
-
pub fn force_always_local(&mut self, nodes: Vec<String>) -> Result<(), HiveLibError> {
89
-
for node in nodes {
90
-
info!("Forcing a local build for {node}");
91
-
92
-
self.nodes
93
-
.get_mut(&Name(Arc::from(node.clone())))
94
-
.ok_or(HiveLibError::HiveInitialisationError(
95
-
HiveInitialisationError::NodeDoesNotExist(node.clone()),
96
-
))?
97
-
.build_remotely = false;
98
-
}
99
-
100
-
Ok(())
101
-
}
102
-
}
103
-
104
-
impl Display for Hive {
105
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
106
-
for (name, node) in &self.nodes {
107
-
writeln!(
108
-
f,
109
-
"Node {} {}:\n",
110
-
name.bold(),
111
-
format!("({})", node.host_platform)
112
-
.italic()
113
-
.if_supports_color(Stream::Stdout, |x| x.dimmed()),
114
-
)?;
115
-
116
-
if !node.tags.is_empty() {
117
-
write!(f, " > {}", "Tags:".bold())?;
118
-
writeln!(f, " {:?}", node.tags)?;
119
-
}
120
-
121
-
write!(f, " > {}", "Connection:".bold())?;
122
-
writeln!(f, " {{{}}}", node.target)?;
123
-
124
-
write!(
125
-
f,
126
-
" > {} {}{}",
127
-
"Build remotely".bold(),
128
-
"`deployment.buildOnTarget`"
129
-
.if_supports_color(Stream::Stdout, |x| x.dimmed())
130
-
.italic(),
131
-
":".bold()
132
-
)?;
133
-
writeln!(f, " {}", node.build_remotely)?;
134
-
135
-
write!(
136
-
f,
137
-
" > {} {}{}",
138
-
"Local apply allowed".bold(),
139
-
"`deployment.allowLocalDeployment`"
140
-
.if_supports_color(Stream::Stdout, |x| x.dimmed())
141
-
.italic(),
142
-
":".bold()
143
-
)?;
144
-
writeln!(f, " {}", node.allow_local_deployment)?;
145
-
146
-
if !node.keys.is_empty() {
147
-
write!(f, " > {}", "Keys:".bold())?;
148
-
writeln!(f, " {} key(s)", node.keys.len())?;
149
-
150
-
for key in &node.keys {
151
-
writeln!(f, " > {key}")?;
152
-
}
153
-
}
154
-
155
-
writeln!(f)?;
156
-
}
157
-
158
-
let total_keys = self
159
-
.nodes
160
-
.values()
161
-
.flat_map(|node| node.keys.iter())
162
-
.collect::<Vec<_>>();
163
-
let distinct_keys = self
164
-
.nodes
165
-
.values()
166
-
.flat_map(|node| node.keys.iter())
167
-
.unique()
168
-
.collect::<Vec<_>>()
169
-
.len();
170
-
171
-
write!(f, "{}", "Summary:".bold())?;
172
-
writeln!(
173
-
f,
174
-
" {} total node(s), totalling {} keys ({distinct_keys} distinct).",
175
-
self.nodes.len(),
176
-
total_keys.len()
177
-
)?;
178
-
writeln!(
179
-
f,
180
-
"{}",
181
-
"Note: Listed connections are tried from Left to Right".italic(),
182
-
)?;
183
-
184
-
Ok(())
185
-
}
186
-
}
187
-
188
-
#[derive(Debug, PartialEq, Eq, Deserialize)]
189
-
pub struct FlakePrefetch {
190
-
pub(crate) hash: String,
191
-
#[serde(rename = "storePath")]
192
-
pub(crate) store_path: String,
193
-
}
194
-
195
-
#[derive(Debug, PartialEq, Eq)]
196
-
pub enum HiveLocation {
197
-
HiveNix(PathBuf),
198
-
Flake {
199
-
uri: String,
200
-
prefetch: FlakePrefetch,
201
-
},
202
-
}
203
-
204
-
impl HiveLocation {
205
-
async fn get_flake(
206
-
uri: String,
207
-
modifiers: SubCommandModifiers,
208
-
) -> Result<HiveLocation, HiveLibError> {
209
-
let command = run_command(
210
-
&CommandArguments::new(format!("nix flake prefetch --extra-experimental-features nix-command --extra-experimental-features flakes --json {uri}"), modifiers)
211
-
.mode(crate::commands::ChildOutputMode::Generic),
212
-
)
213
-
.await?;
214
-
215
-
let result = command
216
-
.wait_till_success()
217
-
.await
218
-
.map_err(HiveLibError::CommandError)?;
219
-
220
-
debug!(hash_json = ?result);
221
-
222
-
let prefetch = serde_json::from_str(&match result {
223
-
Either::Left((.., output)) | Either::Right((.., output)) => output,
224
-
})
225
-
.map_err(|x| {
226
-
HiveLibError::HiveInitialisationError(HiveInitialisationError::ParsePrefetchError(x))
227
-
})?;
228
-
229
-
debug!(prefetch = ?prefetch);
230
-
231
-
Ok(HiveLocation::Flake { uri, prefetch })
232
-
}
233
-
}
234
-
235
-
pub async fn get_hive_location(
236
-
path: String,
237
-
modifiers: SubCommandModifiers,
238
-
) -> Result<HiveLocation, HiveLibError> {
239
-
let flakeref = FlakeRef::from_str(&path);
240
-
241
-
let path_to_location = async |path: PathBuf| {
242
-
Ok(match path.file_name().and_then(OsStr::to_str) {
243
-
Some("hive.nix") => HiveLocation::HiveNix(path.clone()),
244
-
Some(_) => {
245
-
if fs::metadata(path.join("flake.nix")).is_ok() {
246
-
HiveLocation::get_flake(path.display().to_string(), modifiers).await?
247
-
} else {
248
-
HiveLocation::HiveNix(path.join("hive.nix"))
249
-
}
250
-
}
251
-
None => {
252
-
return Err(HiveLibError::HiveLocationError(
253
-
HiveLocationError::MalformedPath(path.clone()),
254
-
));
255
-
}
256
-
})
257
-
};
258
-
259
-
match flakeref {
260
-
Err(nix_compat::flakeref::FlakeRefError::UrlParseError(_err)) => {
261
-
let path = PathBuf::from(path);
262
-
Ok(path_to_location(path).await?)
263
-
}
264
-
Ok(FlakeRef::Path { path, .. }) => Ok(path_to_location(path).await?),
265
-
Ok(
266
-
FlakeRef::Git { .. }
267
-
| FlakeRef::GitHub { .. }
268
-
| FlakeRef::GitLab { .. }
269
-
| FlakeRef::Tarball { .. }
270
-
| FlakeRef::Mercurial { .. }
271
-
| FlakeRef::SourceHut { .. },
272
-
) => Ok(HiveLocation::get_flake(path, modifiers).await?),
273
-
Err(err) => Err(HiveLibError::HiveLocationError(
274
-
HiveLocationError::Malformed(err),
275
-
)),
276
-
Ok(flakeref) => Err(HiveLibError::HiveLocationError(
277
-
HiveLocationError::TypeUnsupported(Box::new(flakeref)),
278
-
)),
279
-
}
280
-
}
281
-
282
-
#[cfg(test)]
283
-
mod tests {
284
-
use im::vector;
285
-
286
-
use crate::{
287
-
errors::CommandError,
288
-
get_test_path,
289
-
hive::steps::keys::{Key, Source, UploadKeyAt},
290
-
location,
291
-
test_support::make_flake_sandbox,
292
-
};
293
-
294
-
use super::*;
295
-
use std::{assert_matches::assert_matches, env};
296
-
297
-
// flake should always come before hive.nix
298
-
#[tokio::test]
299
-
async fn test_hive_dot_nix_priority() {
300
-
let location = location!(get_test_path!());
301
-
302
-
assert_matches!(location, HiveLocation::Flake { .. });
303
-
}
304
-
305
-
#[tokio::test]
306
-
#[cfg_attr(feature = "no_web_tests", ignore)]
307
-
async fn test_hive_file() {
308
-
let location = location!(get_test_path!());
309
-
310
-
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
311
-
.await
312
-
.unwrap();
313
-
314
-
let node = Node {
315
-
target: node::Target::from_host("192.168.122.96"),
316
-
..Default::default()
317
-
};
318
-
319
-
let mut nodes = HashMap::new();
320
-
nodes.insert(Name("node-a".into()), node);
321
-
322
-
assert_eq!(
323
-
hive,
324
-
Hive {
325
-
nodes,
326
-
schema: Hive::SCHEMA_VERSION
327
-
}
328
-
);
329
-
}
330
-
331
-
#[tokio::test]
332
-
#[cfg_attr(feature = "no_web_tests", ignore)]
333
-
async fn non_trivial_hive() {
334
-
let location = location!(get_test_path!());
335
-
336
-
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
337
-
.await
338
-
.unwrap();
339
-
340
-
let node = Node {
341
-
target: node::Target::from_host("name"),
342
-
keys: vector![Key {
343
-
name: "different-than-a".into(),
344
-
dest_dir: "/run/keys/".into(),
345
-
path: "/run/keys/different-than-a".into(),
346
-
group: "root".into(),
347
-
user: "root".into(),
348
-
permissions: "0600".into(),
349
-
source: Source::String("hi".into()),
350
-
upload_at: UploadKeyAt::PreActivation,
351
-
environment: im::HashMap::new()
352
-
}],
353
-
build_remotely: true,
354
-
..Default::default()
355
-
};
356
-
357
-
let mut nodes = HashMap::new();
358
-
nodes.insert(Name("node-a".into()), node);
359
-
360
-
assert_eq!(
361
-
hive,
362
-
Hive {
363
-
nodes,
364
-
schema: Hive::SCHEMA_VERSION
365
-
}
366
-
);
367
-
}
368
-
369
-
#[tokio::test]
370
-
#[cfg_attr(feature = "no_web_tests", ignore)]
371
-
async fn flake_hive() {
372
-
let tmp_dir = make_flake_sandbox(&get_test_path!()).unwrap();
373
-
374
-
let location = get_hive_location(
375
-
tmp_dir.path().display().to_string(),
376
-
SubCommandModifiers::default(),
377
-
)
378
-
.await
379
-
.unwrap();
380
-
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
381
-
.await
382
-
.unwrap();
383
-
384
-
let mut nodes = HashMap::new();
385
-
386
-
// a merged node
387
-
nodes.insert(Name("node-a".into()), Node::from_host("node-a"));
388
-
// a non-merged node
389
-
nodes.insert(Name("node-b".into()), Node::from_host("node-b"));
390
-
391
-
assert_eq!(
392
-
hive,
393
-
Hive {
394
-
nodes,
395
-
schema: Hive::SCHEMA_VERSION
396
-
}
397
-
);
398
-
399
-
tmp_dir.close().unwrap();
400
-
}
401
-
402
-
#[tokio::test]
403
-
async fn no_nixpkgs() {
404
-
let location = location!(get_test_path!());
405
-
406
-
assert_matches!(
407
-
Hive::new_from_path(&location, None, SubCommandModifiers::default()).await,
408
-
Err(HiveLibError::NixEvalError {
409
-
source: CommandError::CommandFailed {
410
-
logs,
411
-
..
412
-
},
413
-
..
414
-
})
415
-
if logs.contains("makeHive called without meta.nixpkgs specified")
416
-
);
417
-
}
418
-
419
-
#[tokio::test]
420
-
async fn _keys_should_fail() {
421
-
let location = location!(get_test_path!());
422
-
423
-
assert_matches!(
424
-
Hive::new_from_path(&location, None, SubCommandModifiers::default()).await,
425
-
Err(HiveLibError::NixEvalError {
426
-
source: CommandError::CommandFailed {
427
-
logs,
428
-
..
429
-
},
430
-
..
431
-
})
432
-
if logs.contains("The option `deployment._keys' is read-only, but it's set multiple times.")
433
-
);
434
-
}
435
-
436
-
#[tokio::test]
437
-
async fn test_force_always_local() {
438
-
let mut location: PathBuf = env::var("WIRE_TEST_DIR").unwrap().into();
439
-
location.push("non_trivial_hive");
440
-
let location = location!(location);
441
-
442
-
let mut hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
443
-
.await
444
-
.unwrap();
445
-
446
-
assert_matches!(
447
-
hive.force_always_local(vec!["non-existent".to_string()]),
448
-
Err(HiveLibError::HiveInitialisationError(
449
-
HiveInitialisationError::NodeDoesNotExist(node)
450
-
)) if node == "non-existent"
451
-
);
452
-
453
-
for node in hive.nodes.values() {
454
-
assert!(node.build_remotely);
455
-
}
456
-
457
-
assert_matches!(hive.force_always_local(vec!["node-a".to_string()]), Ok(()));
458
-
459
-
assert!(
460
-
!hive
461
-
.nodes
462
-
.get(&Name("node-a".into()))
463
-
.unwrap()
464
-
.build_remotely
465
-
);
466
-
}
467
-
}
-805
wire/lib/src/hive/node.rs
-805
wire/lib/src/hive/node.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#![allow(clippy::missing_errors_doc)]
5
-
use enum_dispatch::enum_dispatch;
6
-
use gethostname::gethostname;
7
-
use serde::{Deserialize, Serialize};
8
-
use std::assert_matches::debug_assert_matches;
9
-
use std::fmt::Display;
10
-
use std::sync::Arc;
11
-
use tokio::sync::oneshot;
12
-
use tracing::{Instrument, Level, Span, debug, error, event, instrument, trace};
13
-
14
-
use crate::commands::common::evaluate_hive_attribute;
15
-
use crate::commands::{CommandArguments, WireCommandChip, run_command};
16
-
use crate::errors::NetworkError;
17
-
use crate::hive::HiveLocation;
18
-
use crate::hive::steps::build::Build;
19
-
use crate::hive::steps::cleanup::CleanUp;
20
-
use crate::hive::steps::evaluate::Evaluate;
21
-
use crate::hive::steps::keys::{Key, Keys, PushKeyAgent, UploadKeyAt};
22
-
use crate::hive::steps::ping::Ping;
23
-
use crate::hive::steps::push::{PushBuildOutput, PushEvaluatedOutput};
24
-
use crate::status::STATUS;
25
-
use crate::{EvalGoal, StrictHostKeyChecking, SubCommandModifiers};
26
-
27
-
use super::HiveLibError;
28
-
use super::steps::activate::SwitchToConfiguration;
29
-
30
-
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq, derive_more::Display)]
31
-
pub struct Name(pub Arc<str>);
32
-
33
-
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
34
-
pub struct Target {
35
-
pub hosts: Vec<Arc<str>>,
36
-
pub user: Arc<str>,
37
-
pub port: u32,
38
-
39
-
#[serde(skip)]
40
-
current_host: usize,
41
-
}
42
-
43
-
impl Target {
44
-
#[instrument(ret(level = tracing::Level::DEBUG), skip_all)]
45
-
pub fn create_ssh_opts(
46
-
&self,
47
-
modifiers: SubCommandModifiers,
48
-
master: bool,
49
-
) -> Result<String, HiveLibError> {
50
-
self.create_ssh_args(modifiers, false, master)
51
-
.map(|x| x.join(" "))
52
-
}
53
-
54
-
#[instrument(ret(level = tracing::Level::DEBUG))]
55
-
pub fn create_ssh_args(
56
-
&self,
57
-
modifiers: SubCommandModifiers,
58
-
non_interactive_forced: bool,
59
-
master: bool,
60
-
) -> Result<Vec<String>, HiveLibError> {
61
-
let mut vector = vec![
62
-
"-l".to_string(),
63
-
self.user.to_string(),
64
-
"-p".to_string(),
65
-
self.port.to_string(),
66
-
];
67
-
let mut options = vec![
68
-
format!(
69
-
"StrictHostKeyChecking={}",
70
-
match modifiers.ssh_accept_host {
71
-
StrictHostKeyChecking::AcceptNew => "accept-new",
72
-
StrictHostKeyChecking::No => "no",
73
-
}
74
-
)
75
-
.to_string(),
76
-
];
77
-
78
-
options.extend(["PasswordAuthentication=no".to_string()]);
79
-
options.extend(["KbdInteractiveAuthentication=no".to_string()]);
80
-
81
-
vector.push("-o".to_string());
82
-
vector.extend(options.into_iter().intersperse("-o".to_string()));
83
-
84
-
Ok(vector)
85
-
}
86
-
}
87
-
88
-
#[cfg(test)]
89
-
impl Default for Target {
90
-
fn default() -> Self {
91
-
Target {
92
-
hosts: vec!["NAME".into()],
93
-
user: "root".into(),
94
-
port: 22,
95
-
current_host: 0,
96
-
}
97
-
}
98
-
}
99
-
100
-
#[cfg(test)]
101
-
impl<'a> Context<'a> {
102
-
fn create_test_context(
103
-
hive_location: HiveLocation,
104
-
name: &'a Name,
105
-
node: &'a mut Node,
106
-
) -> Self {
107
-
Context {
108
-
name,
109
-
node,
110
-
hive_location: Arc::new(hive_location),
111
-
modifiers: SubCommandModifiers::default(),
112
-
no_keys: false,
113
-
state: StepState::default(),
114
-
goal: Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch),
115
-
reboot: false,
116
-
should_apply_locally: false,
117
-
handle_unreachable: HandleUnreachable::default(),
118
-
}
119
-
}
120
-
}
121
-
122
-
impl Target {
123
-
pub fn get_preferred_host(&self) -> Result<&Arc<str>, HiveLibError> {
124
-
self.hosts
125
-
.get(self.current_host)
126
-
.ok_or(HiveLibError::NetworkError(NetworkError::HostsExhausted))
127
-
}
128
-
129
-
pub const fn host_failed(&mut self) {
130
-
self.current_host += 1;
131
-
}
132
-
133
-
#[cfg(test)]
134
-
#[must_use]
135
-
pub fn from_host(host: &str) -> Self {
136
-
Target {
137
-
hosts: vec![host.into()],
138
-
..Default::default()
139
-
}
140
-
}
141
-
}
142
-
143
-
impl Display for Target {
144
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
145
-
let hosts = itertools::Itertools::join(
146
-
&mut self
147
-
.hosts
148
-
.iter()
149
-
.map(|host| format!("{}@{host}:{}", self.user, self.port)),
150
-
", ",
151
-
);
152
-
153
-
write!(f, "{hosts}")
154
-
}
155
-
}
156
-
157
-
const fn rollback_default() -> bool {
158
-
true
159
-
}
160
-
161
-
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
162
-
pub struct Node {
163
-
#[serde(rename = "target")]
164
-
pub target: Target,
165
-
166
-
/// default value as this is a new attribute
167
-
#[serde(rename = "rollback", default = "rollback_default")]
168
-
pub rollback: bool,
169
-
170
-
#[serde(rename = "buildOnTarget")]
171
-
pub build_remotely: bool,
172
-
173
-
#[serde(rename = "allowLocalDeployment")]
174
-
pub allow_local_deployment: bool,
175
-
176
-
#[serde(default)]
177
-
pub tags: im::HashSet<String>,
178
-
179
-
#[serde(rename(deserialize = "_keys", serialize = "keys"))]
180
-
pub keys: im::Vector<Key>,
181
-
182
-
#[serde(rename(deserialize = "_hostPlatform", serialize = "host_platform"))]
183
-
pub host_platform: Arc<str>,
184
-
185
-
#[serde(rename(
186
-
deserialize = "privilegeEscalationCommand",
187
-
serialize = "privilege_escalation_command"
188
-
))]
189
-
pub privilege_escalation_command: im::Vector<Arc<str>>,
190
-
}
191
-
192
-
#[cfg(test)]
193
-
impl Default for Node {
194
-
fn default() -> Self {
195
-
Node {
196
-
target: Target::default(),
197
-
keys: im::Vector::new(),
198
-
tags: im::HashSet::new(),
199
-
privilege_escalation_command: vec!["sudo".into(), "--".into()].into(),
200
-
allow_local_deployment: true,
201
-
build_remotely: false,
202
-
host_platform: "x86_64-linux".into(),
203
-
rollback: rollback_default(),
204
-
}
205
-
}
206
-
}
207
-
208
-
impl Node {
209
-
#[cfg(test)]
210
-
#[must_use]
211
-
pub fn from_host(host: &str) -> Self {
212
-
Node {
213
-
target: Target::from_host(host),
214
-
..Default::default()
215
-
}
216
-
}
217
-
218
-
/// Tests the connection to a node
219
-
pub async fn ping(&self, modifiers: SubCommandModifiers) -> Result<(), HiveLibError> {
220
-
let host = self.target.get_preferred_host()?;
221
-
222
-
let command_string = format!(
223
-
"ssh {}@{host} {} exit",
224
-
self.target.user,
225
-
self.target.create_ssh_opts(modifiers, true)?
226
-
);
227
-
228
-
let output = run_command(
229
-
&CommandArguments::new(command_string, modifiers)
230
-
.log_stdout()
231
-
.mode(crate::commands::ChildOutputMode::Interactive),
232
-
)
233
-
.await?;
234
-
235
-
output.wait_till_success().await.map_err(|source| {
236
-
HiveLibError::NetworkError(NetworkError::HostUnreachable {
237
-
host: host.to_string(),
238
-
source,
239
-
})
240
-
})?;
241
-
242
-
Ok(())
243
-
}
244
-
}
245
-
246
-
#[must_use]
247
-
pub fn should_apply_locally(allow_local_deployment: bool, name: &str) -> bool {
248
-
*name == *gethostname() && allow_local_deployment
249
-
}
250
-
251
-
#[derive(derive_more::Display)]
252
-
pub enum Push<'a> {
253
-
Derivation(&'a Derivation),
254
-
Path(&'a String),
255
-
}
256
-
257
-
#[derive(Deserialize, Clone, Debug)]
258
-
pub struct Derivation(String);
259
-
260
-
impl Display for Derivation {
261
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
262
-
self.0.fmt(f).and_then(|()| write!(f, "^*"))
263
-
}
264
-
}
265
-
266
-
#[derive(derive_more::Display, Debug, Clone, Copy)]
267
-
pub enum SwitchToConfigurationGoal {
268
-
Switch,
269
-
Boot,
270
-
Test,
271
-
DryActivate,
272
-
}
273
-
274
-
#[derive(derive_more::Display, Clone, Copy)]
275
-
pub enum Goal {
276
-
SwitchToConfiguration(SwitchToConfigurationGoal),
277
-
Build,
278
-
Push,
279
-
Keys,
280
-
}
281
-
282
-
#[enum_dispatch]
283
-
pub(crate) trait ExecuteStep: Send + Sync + Display + std::fmt::Debug {
284
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError>;
285
-
286
-
fn should_execute(&self, context: &Context) -> bool;
287
-
}
288
-
289
-
// may include other options such as FailAll in the future
290
-
#[non_exhaustive]
291
-
#[derive(Clone, Default)]
292
-
pub enum HandleUnreachable {
293
-
Ignore,
294
-
#[default]
295
-
FailNode,
296
-
}
297
-
298
-
#[derive(Default)]
299
-
pub struct StepState {
300
-
pub evaluation: Option<Derivation>,
301
-
pub evaluation_rx: Option<oneshot::Receiver<Result<Derivation, HiveLibError>>>,
302
-
pub build: Option<String>,
303
-
pub agent_directory: Option<String>,
304
-
}
305
-
306
-
#[allow(clippy::struct_excessive_bools)]
307
-
pub struct Context<'a> {
308
-
pub name: &'a Name,
309
-
pub node: &'a mut Node,
310
-
pub hive_location: Arc<HiveLocation>,
311
-
pub modifiers: SubCommandModifiers,
312
-
pub no_keys: bool,
313
-
pub state: StepState,
314
-
pub goal: Goal,
315
-
pub reboot: bool,
316
-
pub should_apply_locally: bool,
317
-
pub handle_unreachable: HandleUnreachable,
318
-
}
319
-
320
-
#[enum_dispatch(ExecuteStep)]
321
-
#[derive(Debug, PartialEq)]
322
-
enum Step {
323
-
Ping,
324
-
PushKeyAgent,
325
-
Keys,
326
-
Evaluate,
327
-
PushEvaluatedOutput,
328
-
Build,
329
-
PushBuildOutput,
330
-
SwitchToConfiguration,
331
-
CleanUp,
332
-
}
333
-
334
-
impl Display for Step {
335
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
336
-
match self {
337
-
Self::Ping(step) => step.fmt(f),
338
-
Self::PushKeyAgent(step) => step.fmt(f),
339
-
Self::Keys(step) => step.fmt(f),
340
-
Self::Evaluate(step) => step.fmt(f),
341
-
Self::PushEvaluatedOutput(step) => step.fmt(f),
342
-
Self::Build(step) => step.fmt(f),
343
-
Self::PushBuildOutput(step) => step.fmt(f),
344
-
Self::SwitchToConfiguration(step) => step.fmt(f),
345
-
Self::CleanUp(step) => step.fmt(f),
346
-
}
347
-
}
348
-
}
349
-
350
-
pub struct GoalExecutor<'a> {
351
-
steps: Vec<Step>,
352
-
context: Context<'a>,
353
-
}
354
-
355
-
impl<'a> GoalExecutor<'a> {
356
-
#[must_use]
357
-
pub fn new(context: Context<'a>) -> Self {
358
-
Self {
359
-
steps: vec![
360
-
Step::Ping(Ping),
361
-
Step::PushKeyAgent(PushKeyAgent),
362
-
Step::Keys(Keys {
363
-
filter: UploadKeyAt::NoFilter,
364
-
}),
365
-
Step::Keys(Keys {
366
-
filter: UploadKeyAt::PreActivation,
367
-
}),
368
-
Step::Evaluate(super::steps::evaluate::Evaluate),
369
-
Step::PushEvaluatedOutput(super::steps::push::PushEvaluatedOutput),
370
-
Step::Build(super::steps::build::Build),
371
-
Step::PushBuildOutput(super::steps::push::PushBuildOutput),
372
-
Step::SwitchToConfiguration(SwitchToConfiguration),
373
-
Step::Keys(Keys {
374
-
filter: UploadKeyAt::PostActivation,
375
-
}),
376
-
Step::CleanUp(CleanUp),
377
-
],
378
-
context,
379
-
}
380
-
}
381
-
382
-
#[instrument(skip_all, name = "eval")]
383
-
async fn evaluate_task(
384
-
tx: oneshot::Sender<Result<Derivation, HiveLibError>>,
385
-
hive_location: Arc<HiveLocation>,
386
-
name: Name,
387
-
modifiers: SubCommandModifiers,
388
-
) {
389
-
let output =
390
-
evaluate_hive_attribute(&hive_location, &EvalGoal::GetTopLevel(&name), modifiers)
391
-
.await
392
-
.map(|output| {
393
-
serde_json::from_str::<Derivation>(&output).expect("failed to parse derivation")
394
-
});
395
-
396
-
debug!(output = ?output, done = true);
397
-
398
-
let _ = tx.send(output);
399
-
}
400
-
401
-
#[instrument(skip_all, fields(node = %self.context.name))]
402
-
pub async fn execute(mut self) -> Result<(), HiveLibError> {
403
-
let (tx, rx) = oneshot::channel();
404
-
self.context.state.evaluation_rx = Some(rx);
405
-
406
-
// The name of this span should never be changed without updating
407
-
// `wire/cli/tracing_setup.rs`
408
-
debug_assert_matches!(Span::current().metadata().unwrap().name(), "execute");
409
-
// This span should always have a `node` field by the same file
410
-
debug_assert!(
411
-
Span::current()
412
-
.metadata()
413
-
.unwrap()
414
-
.fields()
415
-
.field("node")
416
-
.is_some()
417
-
);
418
-
419
-
if !matches!(self.context.goal, Goal::Keys) {
420
-
tokio::spawn(
421
-
GoalExecutor::evaluate_task(
422
-
tx,
423
-
self.context.hive_location.clone(),
424
-
self.context.name.clone(),
425
-
self.context.modifiers,
426
-
)
427
-
.in_current_span(),
428
-
);
429
-
}
430
-
431
-
let steps = self
432
-
.steps
433
-
.iter()
434
-
.filter(|step| step.should_execute(&self.context))
435
-
.inspect(|step| {
436
-
trace!("Will execute step `{step}` for {}", self.context.name);
437
-
})
438
-
.collect::<Vec<_>>();
439
-
let length = steps.len();
440
-
441
-
for (position, step) in steps.iter().enumerate() {
442
-
event!(
443
-
Level::INFO,
444
-
step = step.to_string(),
445
-
progress = format!("{}/{length}", position + 1)
446
-
);
447
-
448
-
STATUS
449
-
.lock()
450
-
.set_node_step(self.context.name, step.to_string());
451
-
452
-
if let Err(err) = step.execute(&mut self.context).await.inspect_err(|_| {
453
-
error!("Failed to execute `{step}`");
454
-
}) {
455
-
// discard error from cleanup
456
-
let _ = CleanUp.execute(&mut self.context).await;
457
-
458
-
if matches!(step, Step::Ping(..))
459
-
&& matches!(self.context.handle_unreachable, HandleUnreachable::Ignore)
460
-
{
461
-
return Ok(());
462
-
}
463
-
464
-
STATUS.lock().mark_node_failed(self.context.name);
465
-
466
-
return Err(err);
467
-
}
468
-
}
469
-
470
-
STATUS.lock().mark_node_succeeded(self.context.name);
471
-
472
-
Ok(())
473
-
}
474
-
}
475
-
476
-
#[cfg(test)]
477
-
mod tests {
478
-
use rand::distr::Alphabetic;
479
-
480
-
use super::*;
481
-
use crate::{
482
-
function_name, get_test_path,
483
-
hive::{Hive, get_hive_location},
484
-
location,
485
-
};
486
-
use std::{assert_matches::assert_matches, path::PathBuf};
487
-
use std::{collections::HashMap, env};
488
-
489
-
fn get_steps(goal_executor: GoalExecutor) -> std::vec::Vec<Step> {
490
-
goal_executor
491
-
.steps
492
-
.into_iter()
493
-
.filter(|step| step.should_execute(&goal_executor.context))
494
-
.collect::<Vec<_>>()
495
-
}
496
-
497
-
#[tokio::test]
498
-
#[cfg_attr(feature = "no_web_tests", ignore)]
499
-
async fn default_values_match() {
500
-
let mut path = get_test_path!();
501
-
502
-
let location =
503
-
get_hive_location(path.display().to_string(), SubCommandModifiers::default())
504
-
.await
505
-
.unwrap();
506
-
let hive = Hive::new_from_path(&location, None, SubCommandModifiers::default())
507
-
.await
508
-
.unwrap();
509
-
510
-
let node = Node::default();
511
-
512
-
let mut nodes = HashMap::new();
513
-
nodes.insert(Name("NAME".into()), node);
514
-
515
-
path.push("hive.nix");
516
-
517
-
assert_eq!(
518
-
hive,
519
-
Hive {
520
-
nodes,
521
-
schema: Hive::SCHEMA_VERSION
522
-
}
523
-
);
524
-
}
525
-
526
-
#[tokio::test]
527
-
async fn order_build_locally() {
528
-
let location = location!(get_test_path!());
529
-
let mut node = Node {
530
-
build_remotely: false,
531
-
..Default::default()
532
-
};
533
-
let name = &Name(function_name!().into());
534
-
let executor = GoalExecutor::new(Context::create_test_context(location, name, &mut node));
535
-
let steps = get_steps(executor);
536
-
537
-
assert_eq!(
538
-
steps,
539
-
vec![
540
-
Ping.into(),
541
-
PushKeyAgent.into(),
542
-
Keys {
543
-
filter: UploadKeyAt::PreActivation
544
-
}
545
-
.into(),
546
-
crate::hive::steps::evaluate::Evaluate.into(),
547
-
crate::hive::steps::build::Build.into(),
548
-
crate::hive::steps::push::PushBuildOutput.into(),
549
-
SwitchToConfiguration.into(),
550
-
Keys {
551
-
filter: UploadKeyAt::PostActivation
552
-
}
553
-
.into(),
554
-
CleanUp.into()
555
-
]
556
-
);
557
-
}
558
-
559
-
#[tokio::test]
560
-
async fn order_keys_only() {
561
-
let location = location!(get_test_path!());
562
-
let mut node = Node::default();
563
-
let name = &Name(function_name!().into());
564
-
let mut context = Context::create_test_context(location, name, &mut node);
565
-
566
-
context.goal = Goal::Keys;
567
-
568
-
let executor = GoalExecutor::new(context);
569
-
let steps = get_steps(executor);
570
-
571
-
assert_eq!(
572
-
steps,
573
-
vec![
574
-
Ping.into(),
575
-
PushKeyAgent.into(),
576
-
Keys {
577
-
filter: UploadKeyAt::NoFilter
578
-
}
579
-
.into(),
580
-
CleanUp.into()
581
-
]
582
-
);
583
-
}
584
-
585
-
#[tokio::test]
586
-
async fn order_build_only() {
587
-
let location = location!(get_test_path!());
588
-
let mut node = Node::default();
589
-
let name = &Name(function_name!().into());
590
-
let mut context = Context::create_test_context(location, name, &mut node);
591
-
592
-
context.goal = Goal::Build;
593
-
594
-
let executor = GoalExecutor::new(context);
595
-
let steps = get_steps(executor);
596
-
597
-
assert_eq!(
598
-
steps,
599
-
vec![
600
-
Ping.into(),
601
-
crate::hive::steps::evaluate::Evaluate.into(),
602
-
crate::hive::steps::build::Build.into(),
603
-
crate::hive::steps::push::PushBuildOutput.into(),
604
-
CleanUp.into()
605
-
]
606
-
);
607
-
}
608
-
609
-
#[tokio::test]
610
-
async fn order_push_only() {
611
-
let location = location!(get_test_path!());
612
-
let mut node = Node::default();
613
-
let name = &Name(function_name!().into());
614
-
let mut context = Context::create_test_context(location, name, &mut node);
615
-
616
-
context.goal = Goal::Push;
617
-
618
-
let executor = GoalExecutor::new(context);
619
-
let steps = get_steps(executor);
620
-
621
-
assert_eq!(
622
-
steps,
623
-
vec![
624
-
Ping.into(),
625
-
crate::hive::steps::evaluate::Evaluate.into(),
626
-
crate::hive::steps::push::PushEvaluatedOutput.into(),
627
-
CleanUp.into()
628
-
]
629
-
);
630
-
}
631
-
632
-
#[tokio::test]
633
-
async fn order_remote_build() {
634
-
let location = location!(get_test_path!());
635
-
let mut node = Node {
636
-
build_remotely: true,
637
-
..Default::default()
638
-
};
639
-
640
-
let name = &Name(function_name!().into());
641
-
let executor = GoalExecutor::new(Context::create_test_context(location, name, &mut node));
642
-
let steps = get_steps(executor);
643
-
644
-
assert_eq!(
645
-
steps,
646
-
vec![
647
-
Ping.into(),
648
-
PushKeyAgent.into(),
649
-
Keys {
650
-
filter: UploadKeyAt::PreActivation
651
-
}
652
-
.into(),
653
-
crate::hive::steps::evaluate::Evaluate.into(),
654
-
crate::hive::steps::push::PushEvaluatedOutput.into(),
655
-
crate::hive::steps::build::Build.into(),
656
-
SwitchToConfiguration.into(),
657
-
Keys {
658
-
filter: UploadKeyAt::PostActivation
659
-
}
660
-
.into(),
661
-
CleanUp.into()
662
-
]
663
-
);
664
-
}
665
-
666
-
#[test]
667
-
fn target_fails_increments() {
668
-
let mut target = Target::from_host("localhost");
669
-
670
-
assert_eq!(target.current_host, 0);
671
-
672
-
for i in 0..100 {
673
-
target.host_failed();
674
-
assert_eq!(target.current_host, i + 1);
675
-
}
676
-
}
677
-
678
-
#[test]
679
-
fn get_preferred_host_fails() {
680
-
let mut target = Target {
681
-
hosts: vec![
682
-
"un.reachable.1".into(),
683
-
"un.reachable.2".into(),
684
-
"un.reachable.3".into(),
685
-
"un.reachable.4".into(),
686
-
"un.reachable.5".into(),
687
-
],
688
-
..Default::default()
689
-
};
690
-
691
-
assert_ne!(
692
-
target.get_preferred_host().unwrap().to_string(),
693
-
"un.reachable.5"
694
-
);
695
-
696
-
for i in 1..=5 {
697
-
assert_eq!(
698
-
target.get_preferred_host().unwrap().to_string(),
699
-
format!("un.reachable.{i}")
700
-
);
701
-
target.host_failed();
702
-
}
703
-
704
-
for _ in 0..5 {
705
-
assert_matches!(
706
-
target.get_preferred_host(),
707
-
Err(HiveLibError::NetworkError(NetworkError::HostsExhausted))
708
-
);
709
-
}
710
-
}
711
-
712
-
#[test]
713
-
fn test_ssh_opts() {
714
-
let target = Target::from_host("hello-world");
715
-
let subcommand_modifiers = SubCommandModifiers {
716
-
non_interactive: false,
717
-
..Default::default()
718
-
};
719
-
let tmp = format!(
720
-
"/tmp/{}",
721
-
rand::distr::SampleString::sample_string(&Alphabetic, &mut rand::rng(), 10)
722
-
);
723
-
724
-
std::fs::create_dir(&tmp).unwrap();
725
-
726
-
unsafe { env::set_var("XDG_RUNTIME_DIR", &tmp) }
727
-
728
-
let args = [
729
-
"-l".to_string(),
730
-
target.user.to_string(),
731
-
"-p".to_string(),
732
-
target.port.to_string(),
733
-
"-o".to_string(),
734
-
"StrictHostKeyChecking=accept-new".to_string(),
735
-
"-o".to_string(),
736
-
"PasswordAuthentication=no".to_string(),
737
-
"-o".to_string(),
738
-
"KbdInteractiveAuthentication=no".to_string(),
739
-
];
740
-
741
-
assert_eq!(
742
-
target
743
-
.create_ssh_args(subcommand_modifiers, false, false)
744
-
.unwrap(),
745
-
args
746
-
);
747
-
assert_eq!(
748
-
target.create_ssh_opts(subcommand_modifiers, false).unwrap(),
749
-
args.join(" ")
750
-
);
751
-
752
-
assert_eq!(
753
-
target
754
-
.create_ssh_args(subcommand_modifiers, false, true)
755
-
.unwrap(),
756
-
[
757
-
"-l".to_string(),
758
-
target.user.to_string(),
759
-
"-p".to_string(),
760
-
target.port.to_string(),
761
-
"-o".to_string(),
762
-
"StrictHostKeyChecking=accept-new".to_string(),
763
-
"-o".to_string(),
764
-
"PasswordAuthentication=no".to_string(),
765
-
"-o".to_string(),
766
-
"KbdInteractiveAuthentication=no".to_string(),
767
-
]
768
-
);
769
-
770
-
assert_eq!(
771
-
target
772
-
.create_ssh_args(subcommand_modifiers, true, true)
773
-
.unwrap(),
774
-
[
775
-
"-l".to_string(),
776
-
target.user.to_string(),
777
-
"-p".to_string(),
778
-
target.port.to_string(),
779
-
"-o".to_string(),
780
-
"StrictHostKeyChecking=accept-new".to_string(),
781
-
"-o".to_string(),
782
-
"PasswordAuthentication=no".to_string(),
783
-
"-o".to_string(),
784
-
"KbdInteractiveAuthentication=no".to_string(),
785
-
]
786
-
);
787
-
788
-
// forced non interactive is the same as --non-interactive
789
-
assert_eq!(
790
-
target
791
-
.create_ssh_args(subcommand_modifiers, true, false)
792
-
.unwrap(),
793
-
target
794
-
.create_ssh_args(
795
-
SubCommandModifiers {
796
-
non_interactive: true,
797
-
..Default::default()
798
-
},
799
-
false,
800
-
false
801
-
)
802
-
.unwrap()
803
-
);
804
-
}
805
-
}
-248
wire/lib/src/hive/steps/activate.rs
-248
wire/lib/src/hive/steps/activate.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use tracing::{error, info, instrument, warn};
7
-
8
-
use crate::{
9
-
HiveLibError,
10
-
commands::{CommandArguments, WireCommandChip, run_command},
11
-
errors::{ActivationError, CommandError, NetworkError},
12
-
hive::node::{Context, ExecuteStep, Goal, SwitchToConfigurationGoal},
13
-
};
14
-
15
-
#[derive(Debug, PartialEq)]
16
-
pub struct SwitchToConfiguration;
17
-
18
-
impl Display for SwitchToConfiguration {
19
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20
-
write!(f, "switch-to-configuration")
21
-
}
22
-
}
23
-
24
-
async fn wait_for_ping(ctx: &Context<'_>) -> Result<(), HiveLibError> {
25
-
let host = ctx.node.target.get_preferred_host()?;
26
-
let mut result = ctx.node.ping(ctx.modifiers).await;
27
-
28
-
for num in 0..2 {
29
-
warn!("Trying to ping {host} (attempt {}/3)", num + 1);
30
-
31
-
result = ctx.node.ping(ctx.modifiers).await;
32
-
33
-
if result.is_ok() {
34
-
info!("Regained connection to {} via {host}", ctx.name);
35
-
36
-
break;
37
-
}
38
-
}
39
-
40
-
result
41
-
}
42
-
43
-
async fn set_profile(
44
-
goal: SwitchToConfigurationGoal,
45
-
built_path: &String,
46
-
ctx: &Context<'_>,
47
-
) -> Result<(), HiveLibError> {
48
-
info!("Setting profiles in anticipation for switch-to-configuration {goal}");
49
-
50
-
let command_string = format!("nix-env -p /nix/var/nix/profiles/system/ --set {built_path}");
51
-
52
-
let child = run_command(
53
-
&CommandArguments::new(command_string, ctx.modifiers)
54
-
.mode(crate::commands::ChildOutputMode::Nix)
55
-
.on_target(if ctx.should_apply_locally {
56
-
None
57
-
} else {
58
-
Some(&ctx.node.target)
59
-
})
60
-
.elevated(ctx.node),
61
-
)
62
-
.await?;
63
-
64
-
let _ = child
65
-
.wait_till_success()
66
-
.await
67
-
.map_err(HiveLibError::CommandError)?;
68
-
69
-
info!("Set system profile");
70
-
71
-
Ok(())
72
-
}
73
-
74
-
async fn reboot(ctx: &Context<'_>) -> Result<(), HiveLibError> {
75
-
if !ctx.reboot {
76
-
return Ok(());
77
-
}
78
-
79
-
if ctx.should_apply_locally {
80
-
error!("Refusing to reboot local machine!");
81
-
82
-
return Ok(());
83
-
}
84
-
85
-
warn!("Rebooting {name}!", name = ctx.name);
86
-
87
-
let reboot = run_command(
88
-
&CommandArguments::new("reboot now", ctx.modifiers)
89
-
.log_stdout()
90
-
.on_target(Some(&ctx.node.target))
91
-
.elevated(ctx.node),
92
-
)
93
-
.await?;
94
-
95
-
// consume result, impossible to know if the machine failed to reboot or we
96
-
// simply disconnected
97
-
let _ = reboot
98
-
.wait_till_success()
99
-
.await
100
-
.map_err(HiveLibError::CommandError)?;
101
-
102
-
info!("Rebooted {name}, waiting to reconnect...", name = ctx.name);
103
-
104
-
if wait_for_ping(ctx).await.is_ok() {
105
-
return Ok(());
106
-
}
107
-
108
-
error!(
109
-
"Failed to get regain connection to {name} via {host} after reboot.",
110
-
name = ctx.name,
111
-
host = ctx.node.target.get_preferred_host()?
112
-
);
113
-
114
-
return Err(HiveLibError::NetworkError(
115
-
NetworkError::HostUnreachableAfterReboot(ctx.node.target.get_preferred_host()?.to_string()),
116
-
));
117
-
}
118
-
119
-
async fn rollback(
120
-
ctx: &Context<'_>,
121
-
goal: &SwitchToConfigurationGoal,
122
-
original_error: CommandError,
123
-
) -> Result<(), HiveLibError> {
124
-
let command_string = "touch /var/lib/wire-rollback/heartbeat".to_string();
125
-
126
-
let child = run_command(
127
-
&CommandArguments::new(command_string, ctx.modifiers)
128
-
.on_target(Some(&ctx.node.target))
129
-
.elevated(ctx.node)
130
-
.log_stdout(),
131
-
)
132
-
.await?;
133
-
134
-
let result = child.wait_till_success().await;
135
-
136
-
match result {
137
-
Ok(_) => Err(HiveLibError::ActivationError(
138
-
ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), original_error),
139
-
)),
140
-
Err(err) => Err(HiveLibError::ActivationError(
141
-
ActivationError::FailedHeartbeatError {
142
-
name: ctx.name.clone(),
143
-
activation_failure: original_error,
144
-
related_errors: vec![err],
145
-
},
146
-
)),
147
-
}
148
-
}
149
-
150
-
async fn reconnect_or_rollback(
151
-
ctx: &Context<'_>,
152
-
goal: &SwitchToConfigurationGoal,
153
-
error: CommandError,
154
-
) -> Result<(), HiveLibError> {
155
-
warn!(
156
-
"Activation command for {name} exited unsuccessfully.",
157
-
name = ctx.name
158
-
);
159
-
160
-
// Bail if the command couldn't of broken the system
161
-
// and don't try to regain connection to localhost
162
-
if matches!(goal, SwitchToConfigurationGoal::DryActivate) || ctx.should_apply_locally {
163
-
return Err(HiveLibError::ActivationError(
164
-
ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
165
-
));
166
-
}
167
-
168
-
if wait_for_ping(ctx).await.is_ok() {
169
-
if ctx.node.rollback {
170
-
return rollback(ctx, goal, error).await;
171
-
}
172
-
173
-
return Err(HiveLibError::ActivationError(
174
-
ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
175
-
));
176
-
}
177
-
178
-
error!(
179
-
"Failed to get regain connection to {name} via {host} after {goal} activation.",
180
-
name = ctx.name,
181
-
host = ctx.node.target.get_preferred_host()?
182
-
);
183
-
184
-
return Err(HiveLibError::NetworkError(
185
-
NetworkError::HostUnreachableAfterReboot(ctx.node.target.get_preferred_host()?.to_string()),
186
-
));
187
-
}
188
-
189
-
impl ExecuteStep for SwitchToConfiguration {
190
-
fn should_execute(&self, ctx: &Context) -> bool {
191
-
matches!(ctx.goal, Goal::SwitchToConfiguration(..))
192
-
}
193
-
194
-
#[instrument(skip_all, name = "activate")]
195
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
196
-
let built_path = ctx.state.build.as_ref().unwrap();
197
-
198
-
let Goal::SwitchToConfiguration(goal) = &ctx.goal else {
199
-
unreachable!("Cannot reach as guarded by should_execute")
200
-
};
201
-
202
-
if matches!(
203
-
goal,
204
-
// switch profile if switch or boot
205
-
// https://github.com/NixOS/nixpkgs/blob/a2c92aa34735a04010671e3378e2aa2d109b2a72/pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/services.py#L224
206
-
SwitchToConfigurationGoal::Switch | SwitchToConfigurationGoal::Boot
207
-
) {
208
-
set_profile(*goal, built_path, ctx).await?;
209
-
}
210
-
211
-
info!("Running switch-to-configuration {goal}");
212
-
213
-
let goal_str = match goal {
214
-
SwitchToConfigurationGoal::Switch => "switch",
215
-
SwitchToConfigurationGoal::Boot => "boot",
216
-
SwitchToConfigurationGoal::Test => "test",
217
-
SwitchToConfigurationGoal::DryActivate => "dry-activate",
218
-
};
219
-
220
-
let command_string = format!(
221
-
"{rollback}{built_path}/bin/switch-to-configuration {goal_str}",
222
-
rollback = if ctx.node.rollback {
223
-
format!("echo \"{goal_str}\" > /var/lib/wire-rollback/goal && ")
224
-
} else {
225
-
String::new()
226
-
}
227
-
);
228
-
229
-
let child = run_command(
230
-
&CommandArguments::new(command_string, ctx.modifiers)
231
-
.on_target(if ctx.should_apply_locally {
232
-
None
233
-
} else {
234
-
Some(&ctx.node.target)
235
-
})
236
-
.elevated(ctx.node)
237
-
.log_stdout(),
238
-
)
239
-
.await?;
240
-
241
-
let result = child.wait_till_success().await;
242
-
243
-
match result {
244
-
Ok(_) => reboot(ctx).await,
245
-
Err(error) => reconnect_or_rollback(ctx, goal, error).await,
246
-
}
247
-
}
248
-
}
-68
wire/lib/src/hive/steps/build.rs
-68
wire/lib/src/hive/steps/build.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use tracing::{info, instrument};
7
-
8
-
use crate::{
9
-
HiveLibError,
10
-
commands::{CommandArguments, Either, WireCommandChip, run_command_with_env},
11
-
hive::node::{Context, ExecuteStep, Goal},
12
-
};
13
-
14
-
#[derive(Debug, PartialEq)]
15
-
pub struct Build;
16
-
17
-
impl Display for Build {
18
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19
-
write!(f, "Build the node")
20
-
}
21
-
}
22
-
23
-
impl ExecuteStep for Build {
24
-
fn should_execute(&self, ctx: &Context) -> bool {
25
-
!matches!(ctx.goal, Goal::Keys | Goal::Push)
26
-
}
27
-
28
-
#[instrument(skip_all, name = "build")]
29
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
30
-
let top_level = ctx.state.evaluation.as_ref().unwrap();
31
-
32
-
let command_string = format!(
33
-
"nix --extra-experimental-features nix-command \
34
-
build --print-build-logs --no-link --print-out-paths {top_level}"
35
-
);
36
-
37
-
let status = run_command_with_env(
38
-
&CommandArguments::new(command_string, ctx.modifiers)
39
-
// build remotely if asked for AND we arent applying locally
40
-
// building remotely but applying locally does not logically
41
-
// make any sense
42
-
.on_target(if ctx.node.build_remotely && !ctx.should_apply_locally {
43
-
Some(&ctx.node.target)
44
-
} else {
45
-
None
46
-
})
47
-
.mode(crate::commands::ChildOutputMode::Nix)
48
-
.log_stdout(),
49
-
std::collections::HashMap::new(),
50
-
)
51
-
.await?
52
-
.wait_till_success()
53
-
.await
54
-
.map_err(|source| HiveLibError::NixBuildError {
55
-
name: ctx.name.clone(),
56
-
source,
57
-
})?;
58
-
59
-
let stdout = match status {
60
-
Either::Left((_, stdout)) | Either::Right((_, stdout)) => stdout,
61
-
};
62
-
63
-
info!("Built output: {stdout:?}");
64
-
ctx.state.build = Some(stdout);
65
-
66
-
Ok(())
67
-
}
68
-
}
-28
wire/lib/src/hive/steps/cleanup.rs
-28
wire/lib/src/hive/steps/cleanup.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use crate::{
7
-
errors::HiveLibError,
8
-
hive::node::{Context, ExecuteStep},
9
-
};
10
-
11
-
#[derive(PartialEq, Debug)]
12
-
pub(crate) struct CleanUp;
13
-
14
-
impl Display for CleanUp {
15
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16
-
write!(f, "Clean up")
17
-
}
18
-
}
19
-
20
-
impl ExecuteStep for CleanUp {
21
-
fn should_execute(&self, ctx: &Context) -> bool {
22
-
!ctx.should_apply_locally
23
-
}
24
-
25
-
async fn execute(&self, _ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
26
-
Ok(())
27
-
}
28
-
}
-35
wire/lib/src/hive/steps/evaluate.rs
-35
wire/lib/src/hive/steps/evaluate.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use tracing::instrument;
7
-
8
-
use crate::{
9
-
HiveLibError,
10
-
hive::node::{Context, ExecuteStep, Goal},
11
-
};
12
-
13
-
#[derive(Debug, PartialEq)]
14
-
pub struct Evaluate;
15
-
16
-
impl Display for Evaluate {
17
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18
-
write!(f, "Evaluate the node")
19
-
}
20
-
}
21
-
22
-
impl ExecuteStep for Evaluate {
23
-
fn should_execute(&self, ctx: &Context) -> bool {
24
-
!matches!(ctx.goal, Goal::Keys)
25
-
}
26
-
27
-
#[instrument(skip_all, name = "eval")]
28
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
29
-
let rx = ctx.state.evaluation_rx.take().unwrap();
30
-
31
-
ctx.state.evaluation = Some(rx.await.unwrap()?);
32
-
33
-
Ok(())
34
-
}
35
-
}
-329
wire/lib/src/hive/steps/keys.rs
-329
wire/lib/src/hive/steps/keys.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use base64::Engine;
5
-
use base64::prelude::BASE64_STANDARD;
6
-
use futures::future::join_all;
7
-
use itertools::{Itertools, Position};
8
-
use owo_colors::OwoColorize;
9
-
use prost::Message;
10
-
use prost::bytes::BytesMut;
11
-
use serde::{Deserialize, Serialize};
12
-
use sha2::{Digest, Sha256};
13
-
use std::env;
14
-
use std::fmt::Display;
15
-
use std::io::Cursor;
16
-
use std::path::PathBuf;
17
-
use std::pin::Pin;
18
-
use std::process::Stdio;
19
-
use std::str::from_utf8;
20
-
use tokio::io::AsyncReadExt as _;
21
-
use tokio::process::Command;
22
-
use tokio::{fs::File, io::AsyncRead};
23
-
use tokio_util::codec::LengthDelimitedCodec;
24
-
use tracing::{debug, instrument};
25
-
26
-
use crate::HiveLibError;
27
-
use crate::commands::common::push;
28
-
use crate::commands::{CommandArguments, WireCommandChip, run_command};
29
-
use crate::errors::KeyError;
30
-
use crate::hive::node::{Context, ExecuteStep, Goal, Push, SwitchToConfigurationGoal};
31
-
32
-
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
33
-
#[serde(tag = "t", content = "c")]
34
-
pub enum Source {
35
-
String(String),
36
-
Path(PathBuf),
37
-
Command(Vec<String>),
38
-
}
39
-
40
-
#[derive(Serialize, Deserialize, Clone, Debug, Hash, Eq, PartialEq)]
41
-
pub enum UploadKeyAt {
42
-
#[serde(rename = "pre-activation")]
43
-
PreActivation,
44
-
#[serde(rename = "post-activation")]
45
-
PostActivation,
46
-
#[serde(skip)]
47
-
NoFilter,
48
-
}
49
-
50
-
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
51
-
pub struct Key {
52
-
pub name: String,
53
-
#[serde(rename = "destDir")]
54
-
pub dest_dir: String,
55
-
pub path: PathBuf,
56
-
pub group: String,
57
-
pub user: String,
58
-
pub permissions: String,
59
-
pub source: Source,
60
-
#[serde(rename = "uploadAt")]
61
-
pub upload_at: UploadKeyAt,
62
-
#[serde(default)]
63
-
pub environment: im::HashMap<String, String>,
64
-
}
65
-
66
-
impl Display for Key {
67
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68
-
write!(
69
-
f,
70
-
"{} {} {}:{} {}",
71
-
match self.source {
72
-
Source::String(_) => "Literal",
73
-
Source::Path(_) => "Path",
74
-
Source::Command(_) => "Command",
75
-
}
76
-
.if_supports_color(owo_colors::Stream::Stdout, |x| x.dimmed()),
77
-
[self.dest_dir.clone(), self.name.clone()]
78
-
.iter()
79
-
.collect::<PathBuf>()
80
-
.display(),
81
-
self.user,
82
-
self.group,
83
-
self.permissions,
84
-
)
85
-
}
86
-
}
87
-
88
-
fn get_u32_permission(key: &Key) -> Result<u32, KeyError> {
89
-
u32::from_str_radix(&key.permissions, 8).map_err(KeyError::ParseKeyPermissions)
90
-
}
91
-
92
-
async fn create_reader(key: &'_ Key) -> Result<Pin<Box<dyn AsyncRead + Send + '_>>, KeyError> {
93
-
match &key.source {
94
-
Source::Path(path) => Ok(Box::pin(File::open(path).await.map_err(KeyError::File)?)),
95
-
Source::String(string) => Ok(Box::pin(Cursor::new(string))),
96
-
Source::Command(args) => {
97
-
let output = Command::new(args.first().ok_or(KeyError::Empty)?)
98
-
.args(&args[1..])
99
-
.stdin(Stdio::null())
100
-
.stdout(Stdio::piped())
101
-
.stderr(Stdio::piped())
102
-
.envs(key.environment.clone())
103
-
.spawn()
104
-
.map_err(|err| KeyError::CommandSpawnError {
105
-
error: err,
106
-
command: args.join(" "),
107
-
command_span: Some((0..args.first().unwrap().len()).into()),
108
-
})?
109
-
.wait_with_output()
110
-
.await
111
-
.map_err(|err| KeyError::CommandResolveError {
112
-
error: err,
113
-
command: args.join(" "),
114
-
})?;
115
-
116
-
if output.status.success() {
117
-
return Ok(Box::pin(Cursor::new(output.stdout)));
118
-
}
119
-
120
-
Err(KeyError::CommandError(
121
-
output.status,
122
-
from_utf8(&output.stderr).unwrap().to_string(),
123
-
))
124
-
}
125
-
}
126
-
}
127
-
128
-
async fn process_key(key: &Key) -> Result<(agent::keys::KeySpec, Vec<u8>), KeyError> {
129
-
let mut reader = create_reader(key).await?;
130
-
131
-
let mut buf = Vec::new();
132
-
133
-
reader
134
-
.read_to_end(&mut buf)
135
-
.await
136
-
.expect("failed to read into buffer");
137
-
138
-
let destination: PathBuf = [key.dest_dir.clone(), key.name.clone()].iter().collect();
139
-
140
-
debug!("Staging push to {}", destination.clone().display());
141
-
142
-
Ok((
143
-
agent::keys::KeySpec {
144
-
length: buf
145
-
.len()
146
-
.try_into()
147
-
.expect("Failed to convert usize buf length to i32"),
148
-
user: key.user.clone(),
149
-
group: key.group.clone(),
150
-
permissions: get_u32_permission(key)?,
151
-
destination: destination.into_os_string().into_string().unwrap(),
152
-
digest: Sha256::digest(&buf).to_vec(),
153
-
last: false,
154
-
},
155
-
buf,
156
-
))
157
-
}
158
-
159
-
#[derive(Debug, PartialEq)]
160
-
pub struct Keys {
161
-
pub filter: UploadKeyAt,
162
-
}
163
-
#[derive(Debug, PartialEq)]
164
-
pub struct PushKeyAgent;
165
-
166
-
impl Display for Keys {
167
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
168
-
write!(f, "Upload key @ {:?}", self.filter)
169
-
}
170
-
}
171
-
172
-
impl Display for PushKeyAgent {
173
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
174
-
write!(f, "Push the key agent")
175
-
}
176
-
}
177
-
178
-
pub struct SimpleLengthDelimWriter<F> {
179
-
codec: LengthDelimitedCodec,
180
-
write_fn: F,
181
-
}
182
-
183
-
impl<F> SimpleLengthDelimWriter<F>
184
-
where
185
-
F: AsyncFnMut(Vec<u8>) -> Result<(), HiveLibError>,
186
-
{
187
-
fn new(write_fn: F) -> Self {
188
-
Self {
189
-
codec: LengthDelimitedCodec::new(),
190
-
write_fn,
191
-
}
192
-
}
193
-
194
-
async fn send(&mut self, data: prost::bytes::Bytes) -> Result<(), HiveLibError> {
195
-
let mut buffer = BytesMut::new();
196
-
tokio_util::codec::Encoder::encode(&mut self.codec, data, &mut buffer)
197
-
.map_err(HiveLibError::Encoding)?;
198
-
199
-
(self.write_fn)(buffer.to_vec()).await?;
200
-
Ok(())
201
-
}
202
-
}
203
-
204
-
impl ExecuteStep for Keys {
205
-
fn should_execute(&self, ctx: &Context) -> bool {
206
-
if ctx.no_keys {
207
-
return false;
208
-
}
209
-
210
-
// should execute if no filter, and the goal is keys.
211
-
// otherwise, only execute if the goal is switch and non-nofilter
212
-
matches!(
213
-
(&self.filter, &ctx.goal),
214
-
(UploadKeyAt::NoFilter, Goal::Keys)
215
-
| (
216
-
UploadKeyAt::PreActivation | UploadKeyAt::PostActivation,
217
-
Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch)
218
-
)
219
-
)
220
-
}
221
-
222
-
#[instrument(skip_all, name = "keys")]
223
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
224
-
let agent_directory = ctx.state.agent_directory.as_ref().unwrap();
225
-
226
-
let futures = ctx
227
-
.node
228
-
.keys
229
-
.iter()
230
-
.filter(|key| {
231
-
self.filter == UploadKeyAt::NoFilter
232
-
|| (self.filter != UploadKeyAt::NoFilter && key.upload_at != self.filter)
233
-
})
234
-
.map(|key| async move {
235
-
process_key(key)
236
-
.await
237
-
.map_err(|err| HiveLibError::KeyError(key.name.clone(), err))
238
-
});
239
-
240
-
let mut keys = join_all(futures)
241
-
.await
242
-
.into_iter()
243
-
.collect::<Result<Vec<_>, HiveLibError>>()?
244
-
.into_iter()
245
-
.peekable();
246
-
247
-
if keys.peek().is_none() {
248
-
debug!("Had no keys to push, ending KeyStep early.");
249
-
return Ok(());
250
-
}
251
-
252
-
let command_string = format!("{agent_directory}/bin/agent");
253
-
254
-
let mut child = run_command(
255
-
&CommandArguments::new(command_string, ctx.modifiers)
256
-
.on_target(if ctx.should_apply_locally {
257
-
None
258
-
} else {
259
-
Some(&ctx.node.target)
260
-
})
261
-
.elevated(ctx.node)
262
-
.keep_stdin_open()
263
-
.log_stdout(),
264
-
)
265
-
.await?;
266
-
267
-
let mut writer = SimpleLengthDelimWriter::new(async |data| child.write_stdin(data).await);
268
-
269
-
for (position, (mut spec, buf)) in keys.with_position() {
270
-
if matches!(position, Position::Last | Position::Only) {
271
-
spec.last = true;
272
-
}
273
-
274
-
debug!("Writing spec & buf for {:?}", spec);
275
-
276
-
writer
277
-
.send(BASE64_STANDARD.encode(spec.encode_to_vec()).into())
278
-
.await?;
279
-
writer.send(BASE64_STANDARD.encode(buf).into()).await?;
280
-
}
281
-
282
-
let status = child
283
-
.wait_till_success()
284
-
.await
285
-
.map_err(HiveLibError::CommandError)?;
286
-
287
-
debug!("status: {status:?}");
288
-
289
-
Ok(())
290
-
}
291
-
}
292
-
293
-
impl ExecuteStep for PushKeyAgent {
294
-
fn should_execute(&self, ctx: &Context) -> bool {
295
-
if ctx.no_keys {
296
-
return false;
297
-
}
298
-
299
-
matches!(
300
-
&ctx.goal,
301
-
Goal::Keys | Goal::SwitchToConfiguration(SwitchToConfigurationGoal::Switch)
302
-
)
303
-
}
304
-
305
-
#[instrument(skip_all, name = "push_agent")]
306
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
307
-
let arg_name = format!(
308
-
"WIRE_AGENT_{platform}",
309
-
platform = ctx.node.host_platform.replace('-', "_")
310
-
);
311
-
312
-
let agent_directory = match env::var_os(&arg_name) {
313
-
Some(agent) => agent.into_string().unwrap(),
314
-
None => panic!(
315
-
"{arg_name} environment variable not set! \n
316
-
wire was not built with the ability to deploy keys to this platform. \n
317
-
Please create an issue: https://github.com/mrshmllow/wire/issues/new?template=bug_report.md"
318
-
),
319
-
};
320
-
321
-
if !ctx.should_apply_locally {
322
-
push(ctx, Push::Path(&agent_directory)).await?;
323
-
}
324
-
325
-
ctx.state.agent_directory = Some(agent_directory);
326
-
327
-
Ok(())
328
-
}
329
-
}
-10
wire/lib/src/hive/steps/mod.rs
-10
wire/lib/src/hive/steps/mod.rs
-54
wire/lib/src/hive/steps/ping.rs
-54
wire/lib/src/hive/steps/ping.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use tracing::{Level, event, instrument};
7
-
8
-
use crate::{
9
-
HiveLibError,
10
-
hive::node::{Context, ExecuteStep},
11
-
};
12
-
13
-
#[derive(Debug, PartialEq)]
14
-
pub struct Ping;
15
-
16
-
impl Display for Ping {
17
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18
-
write!(f, "Ping node")
19
-
}
20
-
}
21
-
22
-
impl ExecuteStep for Ping {
23
-
fn should_execute(&self, ctx: &Context) -> bool {
24
-
!ctx.should_apply_locally
25
-
}
26
-
27
-
#[instrument(skip_all, name = "ping")]
28
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
29
-
loop {
30
-
event!(
31
-
Level::INFO,
32
-
status = "attempting",
33
-
host = ctx.node.target.get_preferred_host()?.to_string()
34
-
);
35
-
36
-
if ctx.node.ping(ctx.modifiers).await.is_ok() {
37
-
event!(
38
-
Level::INFO,
39
-
status = "success",
40
-
host = ctx.node.target.get_preferred_host()?.to_string()
41
-
);
42
-
return Ok(());
43
-
}
44
-
45
-
// ? will take us out if we ran out of hosts
46
-
event!(
47
-
Level::WARN,
48
-
status = "failed to ping",
49
-
host = ctx.node.target.get_preferred_host()?.to_string()
50
-
);
51
-
ctx.node.target.host_failed();
52
-
}
53
-
}
54
-
}
-76
wire/lib/src/hive/steps/push.rs
-76
wire/lib/src/hive/steps/push.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::fmt::Display;
5
-
6
-
use tracing::instrument;
7
-
8
-
use crate::{
9
-
HiveLibError,
10
-
commands::common::push,
11
-
hive::node::{Context, ExecuteStep, Goal},
12
-
};
13
-
14
-
#[derive(Debug, PartialEq)]
15
-
pub struct PushEvaluatedOutput;
16
-
#[derive(Debug, PartialEq)]
17
-
pub struct PushBuildOutput;
18
-
19
-
impl Display for PushEvaluatedOutput {
20
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21
-
write!(f, "Push the evaluated output")
22
-
}
23
-
}
24
-
25
-
impl Display for PushBuildOutput {
26
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27
-
write!(f, "Push the build output")
28
-
}
29
-
}
30
-
31
-
impl ExecuteStep for PushEvaluatedOutput {
32
-
fn should_execute(&self, ctx: &Context) -> bool {
33
-
!matches!(ctx.goal, Goal::Keys)
34
-
&& !ctx.should_apply_locally
35
-
&& (ctx.node.build_remotely | matches!(ctx.goal, Goal::Push))
36
-
}
37
-
38
-
#[instrument(skip_all, name = "push_eval")]
39
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
40
-
let top_level = ctx.state.evaluation.as_ref().unwrap();
41
-
42
-
push(ctx, crate::hive::node::Push::Derivation(top_level)).await?;
43
-
44
-
Ok(())
45
-
}
46
-
}
47
-
48
-
impl ExecuteStep for PushBuildOutput {
49
-
fn should_execute(&self, ctx: &Context) -> bool {
50
-
if matches!(ctx.goal, Goal::Keys | Goal::Push) {
51
-
// skip if we are not building
52
-
return false;
53
-
}
54
-
55
-
if ctx.node.build_remotely {
56
-
// skip if we are building remotely
57
-
return false;
58
-
}
59
-
60
-
if ctx.should_apply_locally {
61
-
// skip step if we are applying locally
62
-
return false;
63
-
}
64
-
65
-
true
66
-
}
67
-
68
-
#[instrument(skip_all, name = "push_build")]
69
-
async fn execute(&self, ctx: &mut Context<'_>) -> Result<(), HiveLibError> {
70
-
let built_path = ctx.state.build.as_ref().unwrap();
71
-
72
-
push(ctx, crate::hive::node::Push::Path(built_path)).await?;
73
-
74
-
Ok(())
75
-
}
76
-
}
-71
wire/lib/src/lib.rs
-71
wire/lib/src/lib.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#![feature(assert_matches)]
5
-
#![feature(iter_intersperse)]
6
-
#![feature(sync_nonpoison)]
7
-
#![feature(nonpoison_mutex)]
8
-
9
-
use std::{
10
-
io::{IsTerminal, stderr},
11
-
sync::LazyLock,
12
-
};
13
-
14
-
use tokio::sync::{AcquireError, Semaphore, SemaphorePermit};
15
-
16
-
use crate::{errors::HiveLibError, hive::node::Name, status::STATUS};
17
-
18
-
pub mod cache;
19
-
pub mod commands;
20
-
pub mod hive;
21
-
pub mod status;
22
-
23
-
#[cfg(test)]
24
-
mod test_macros;
25
-
26
-
#[cfg(test)]
27
-
mod test_support;
28
-
29
-
pub mod errors;
30
-
31
-
#[derive(Clone, Debug, Copy, Default)]
32
-
pub enum StrictHostKeyChecking {
33
-
/// do not accept new host. dangerous!
34
-
No,
35
-
36
-
/// accept-new, default
37
-
#[default]
38
-
AcceptNew,
39
-
}
40
-
41
-
#[derive(Debug, Clone, Copy)]
42
-
pub struct SubCommandModifiers {
43
-
pub show_trace: bool,
44
-
pub non_interactive: bool,
45
-
pub ssh_accept_host: StrictHostKeyChecking,
46
-
}
47
-
48
-
impl Default for SubCommandModifiers {
49
-
fn default() -> Self {
50
-
SubCommandModifiers {
51
-
show_trace: false,
52
-
non_interactive: !std::io::stdin().is_terminal(),
53
-
ssh_accept_host: StrictHostKeyChecking::default(),
54
-
}
55
-
}
56
-
}
57
-
58
-
pub enum EvalGoal<'a> {
59
-
Inspect,
60
-
Names,
61
-
GetTopLevel(&'a Name),
62
-
}
63
-
64
-
pub static STDIN_CLOBBER_LOCK: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(1));
65
-
66
-
pub async fn aquire_stdin_lock<'a>() -> Result<SemaphorePermit<'a>, AcquireError> {
67
-
let result = STDIN_CLOBBER_LOCK.acquire().await?;
68
-
STATUS.lock().wipe_out(&mut stderr());
69
-
70
-
Ok(result)
71
-
}
-173
wire/lib/src/status.rs
-173
wire/lib/src/status.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use owo_colors::OwoColorize;
5
-
use std::{fmt::Write, time::Instant};
6
-
use termion::{clear, cursor};
7
-
8
-
use crate::{STDIN_CLOBBER_LOCK, hive::node::Name};
9
-
10
-
use std::{
11
-
collections::HashMap,
12
-
sync::{LazyLock, nonpoison::Mutex},
13
-
};
14
-
15
-
#[derive(Default)]
16
-
pub enum NodeStatus {
17
-
#[default]
18
-
Pending,
19
-
Running(String),
20
-
Succeeded,
21
-
Failed,
22
-
}
23
-
24
-
pub struct Status {
25
-
statuses: HashMap<String, NodeStatus>,
26
-
began: Instant,
27
-
show_progress: bool,
28
-
}
29
-
30
-
/// global status used for the progress bar in the cli crate
31
-
pub static STATUS: LazyLock<Mutex<Status>> = LazyLock::new(|| Mutex::new(Status::new()));
32
-
33
-
impl Status {
34
-
fn new() -> Self {
35
-
Self {
36
-
statuses: HashMap::default(),
37
-
began: Instant::now(),
38
-
show_progress: false,
39
-
}
40
-
}
41
-
42
-
pub const fn show_progress(&mut self, show_progress: bool) {
43
-
self.show_progress = show_progress;
44
-
}
45
-
46
-
pub fn add_many(&mut self, names: &[&Name]) {
47
-
self.statuses.extend(
48
-
names
49
-
.iter()
50
-
.map(|name| (name.0.to_string(), NodeStatus::Pending)),
51
-
);
52
-
}
53
-
54
-
pub fn set_node_step(&mut self, node: &Name, step: String) {
55
-
self.statuses
56
-
.insert(node.0.to_string(), NodeStatus::Running(step));
57
-
}
58
-
59
-
pub fn mark_node_failed(&mut self, node: &Name) {
60
-
self.statuses.insert(node.0.to_string(), NodeStatus::Failed);
61
-
}
62
-
63
-
pub fn mark_node_succeeded(&mut self, node: &Name) {
64
-
self.statuses
65
-
.insert(node.0.to_string(), NodeStatus::Succeeded);
66
-
}
67
-
68
-
#[must_use]
69
-
fn num_finished(&self) -> usize {
70
-
self.statuses
71
-
.iter()
72
-
.filter(|(_, status)| matches!(status, NodeStatus::Succeeded | NodeStatus::Failed))
73
-
.count()
74
-
}
75
-
76
-
#[must_use]
77
-
fn num_running(&self) -> usize {
78
-
self.statuses
79
-
.iter()
80
-
.filter(|(_, status)| matches!(status, NodeStatus::Running(..)))
81
-
.count()
82
-
}
83
-
84
-
#[must_use]
85
-
fn num_failed(&self) -> usize {
86
-
self.statuses
87
-
.iter()
88
-
.filter(|(_, status)| matches!(status, NodeStatus::Failed))
89
-
.count()
90
-
}
91
-
92
-
#[must_use]
93
-
pub fn get_msg(&self) -> String {
94
-
if self.statuses.is_empty() {
95
-
return String::new();
96
-
}
97
-
98
-
let mut msg = format!("[{} / {}", self.num_finished(), self.statuses.len(),);
99
-
100
-
let num_failed = self.num_failed();
101
-
let num_running = self.num_running();
102
-
103
-
let failed = if num_failed >= 1 {
104
-
Some(format!("{} Failed", num_failed.red()))
105
-
} else {
106
-
None
107
-
};
108
-
109
-
let running = if num_running >= 1 {
110
-
Some(format!("{} Deploying", num_running.blue()))
111
-
} else {
112
-
None
113
-
};
114
-
115
-
let _ = match (failed, running) {
116
-
(None, None) => write!(&mut msg, ""),
117
-
(Some(message), None) | (None, Some(message)) => write!(&mut msg, " ({message})"),
118
-
(Some(failed), Some(running)) => write!(&mut msg, " ({failed}, {running})"),
119
-
};
120
-
121
-
let _ = write!(&mut msg, "]");
122
-
123
-
let _ = write!(&mut msg, " {}s", self.began.elapsed().as_secs());
124
-
125
-
msg
126
-
}
127
-
128
-
pub fn clear<T: std::io::Write>(&self, writer: &mut T) {
129
-
if !self.show_progress {
130
-
return;
131
-
}
132
-
133
-
let _ = write!(writer, "{}", cursor::Save);
134
-
// let _ = write!(writer, "{}", cursor::Down(1));
135
-
let _ = write!(writer, "{}", cursor::Left(999));
136
-
let _ = write!(writer, "{}", clear::CurrentLine);
137
-
}
138
-
139
-
/// used when there is an interactive prompt
140
-
pub fn wipe_out<T: std::io::Write>(&self, writer: &mut T) {
141
-
if !self.show_progress {
142
-
return;
143
-
}
144
-
145
-
let _ = write!(writer, "{}", cursor::Save);
146
-
let _ = write!(writer, "{}", cursor::Left(999));
147
-
let _ = write!(writer, "{}", clear::CurrentLine);
148
-
let _ = writer.flush();
149
-
}
150
-
151
-
pub fn write_status<T: std::io::Write>(&mut self, writer: &mut T) {
152
-
if self.show_progress {
153
-
let _ = write!(writer, "{}", self.get_msg());
154
-
}
155
-
}
156
-
157
-
pub fn write_above_status<T: std::io::Write>(
158
-
&mut self,
159
-
buf: &[u8],
160
-
writer: &mut T,
161
-
) -> std::io::Result<usize> {
162
-
if STDIN_CLOBBER_LOCK.available_permits() != 1 {
163
-
// skip
164
-
return Ok(0);
165
-
}
166
-
167
-
self.clear(writer);
168
-
let written = writer.write(buf)?;
169
-
self.write_status(writer);
170
-
171
-
Ok(written)
172
-
}
173
-
}
-43
wire/lib/src/test_macros.rs
-43
wire/lib/src/test_macros.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
#[macro_export]
5
-
macro_rules! function_name {
6
-
() => {{
7
-
fn f() {}
8
-
fn type_name_of<T>(_: T) -> &'static str {
9
-
std::any::type_name::<T>()
10
-
}
11
-
let name = type_name_of(f);
12
-
// closure for async functions
13
-
&name[..name.len() - 3]
14
-
}};
15
-
}
16
-
17
-
#[macro_export]
18
-
macro_rules! get_test_path {
19
-
() => {{
20
-
let mut path: PathBuf = env::var("WIRE_TEST_DIR").unwrap().into();
21
-
let full_name = $crate::function_name!();
22
-
let function_name = full_name
23
-
.trim_end_matches("::{{closure}}")
24
-
.split("::")
25
-
.last()
26
-
.unwrap();
27
-
path.push(function_name);
28
-
29
-
path
30
-
}};
31
-
}
32
-
33
-
#[macro_export]
34
-
macro_rules! location {
35
-
($path:expr) => {{
36
-
$crate::hive::get_hive_location(
37
-
$path.display().to_string(),
38
-
$crate::SubCommandModifiers::default(),
39
-
)
40
-
.await
41
-
.unwrap()
42
-
}};
43
-
}
-67
wire/lib/src/test_support.rs
-67
wire/lib/src/test_support.rs
···
1
-
// SPDX-License-Identifier: AGPL-3.0-or-later
2
-
// Copyright 2024-2025 wire Contributors
3
-
4
-
use std::{
5
-
fs::{self, create_dir},
6
-
io,
7
-
path::Path,
8
-
process::Command,
9
-
};
10
-
11
-
use tempdir::TempDir;
12
-
13
-
pub fn make_flake_sandbox(path: &Path) -> Result<TempDir, io::Error> {
14
-
let tmp_dir = TempDir::new("wire-test")?;
15
-
16
-
Command::new("git")
17
-
.args(["init", "-b", "tmp"])
18
-
.current_dir(tmp_dir.path())
19
-
.status()?;
20
-
21
-
for entry in fs::read_dir(path)? {
22
-
let entry = entry?;
23
-
24
-
fs::copy(entry.path(), tmp_dir.as_ref().join(entry.file_name()))?;
25
-
}
26
-
27
-
let root = path.parent().unwrap().parent().unwrap().parent().unwrap();
28
-
29
-
create_dir(tmp_dir.as_ref().join("module/"))?;
30
-
31
-
fs::copy(
32
-
root.join(Path::new("runtime/evaluate.nix")),
33
-
tmp_dir.as_ref().join("evaluate.nix"),
34
-
)?;
35
-
fs::copy(
36
-
root.join(Path::new("runtime/module/config.nix")),
37
-
tmp_dir.as_ref().join("module/config.nix"),
38
-
)?;
39
-
fs::copy(
40
-
root.join(Path::new("runtime/module/options.nix")),
41
-
tmp_dir.as_ref().join("module/options.nix"),
42
-
)?;
43
-
fs::copy(
44
-
root.join(Path::new("runtime/module/default.nix")),
45
-
tmp_dir.as_ref().join("module/default.nix"),
46
-
)?;
47
-
fs::copy(
48
-
root.join(Path::new("runtime/makeHive.nix")),
49
-
tmp_dir.as_ref().join("makeHive.nix"),
50
-
)?;
51
-
fs::copy(
52
-
root.join(Path::new("flake.lock")),
53
-
tmp_dir.as_ref().join("flake.lock"),
54
-
)?;
55
-
56
-
Command::new("git")
57
-
.args(["add", "-A"])
58
-
.current_dir(tmp_dir.path())
59
-
.status()?;
60
-
61
-
Command::new("nix")
62
-
.args(["flake", "lock"])
63
-
.current_dir(tmp_dir.path())
64
-
.status()?;
65
-
66
-
Ok(tmp_dir)
67
-
}