Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai 031e59f484 fix(ui): show cut-off text whole in a tooltip
Text shortened with an ellipsis in tool windows, popups and tabs gave no way to read
it whole. The tooltip host now shows such text in full after the usual delay, only while
it is actually cut off and when it has no native title. Inside an element with a tooltip
of its own (an editor tab, a commit-panel file with its change kind) the whole text
comes first and the element's own tooltip beside it.
2026-11-17 00:53:44 +08:00
1196 змінених файлів з 19640 додано та 68177 видалено

No files matched your search

-3
Переглянути файл
@@ -98,9 +98,6 @@ jobs:
# Test fixtures write LF files; keep Git from converting them on checkout.
- run: git config --global core.autocrlf false
- run: cargo nextest run --workspace --no-fail-fast
# nextest skips doctests; ide-command's are its compile-fail tests.
- if: runner.os == 'Linux'
run: cargo test --doc -p ide-command
# nextest ran export_bindings, which rewrites src/bindings.ts and the command snapshot.
- name: Bindings and command snapshot are up to date
if: runner.os == 'Linux'
+119
Переглянути файл
@@ -0,0 +1,119 @@
name: Nightly
# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
# version, so remote development finds the server of that version. The `nightly` release holds
# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
# nothing newer stops there. Only the latest builds are kept.
on:
schedule:
- cron: "17 2,14 * * *"
workflow_dispatch:
inputs:
force:
description: "Build even if nothing is newer than the last nightly"
type: boolean
default: false
permissions:
contents: read
concurrency:
group: nightly
env:
GH_TOKEN: ${{ github.token }}
GH_REPO: ${{ github.repository }}
jobs:
prepare:
permissions:
actions: read
contents: write
if: github.repository == 'l0ng-ai/openidea'
runs-on: ubuntu-latest
outputs:
sha: ${{ steps.commit.outputs.sha }}
tag: ${{ steps.release.outputs.tag }}
release_id: ${{ steps.release.outputs.id }}
steps:
- id: commit
env:
FORCE: ${{ inputs.force }}
run: |
sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
--json headSha --jq '.[0].headSha // ""')"
if [ -z "$sha" ]; then
echo "::notice::no main commit has passed CI"
exit 0
fi
# No `nightly` tag yet (the first run): compare fails and the build goes on.
status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null)" || status=ahead
if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
echo "::notice::$sha is not newer than the last nightly"
exit 0
fi
echo "sha=$sha" >> "$GITHUB_OUTPUT"
- uses: actions/checkout@v5
if: steps.commit.outputs.sha != ''
with: { ref: "${{ steps.commit.outputs.sha }}" }
- uses: actions/setup-node@v5
if: steps.commit.outputs.sha != ''
with: { node-version: 22 }
- uses: dtolnay/rust-toolchain@stable
if: steps.commit.outputs.sha != ''
- id: release
if: steps.commit.outputs.sha != ''
env:
SHA: ${{ steps.commit.outputs.sha }}
run: |
version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
tag="v$version"
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git commit -am "chore: $tag"
git tag "$tag"
git push origin "$tag"
id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
-F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
echo "tag=$tag" >> "$GITHUB_OUTPUT"
echo "id=$id" >> "$GITHUB_OUTPUT"
binaries:
permissions:
contents: write
needs: prepare
if: needs.prepare.outputs.tag != ''
uses: ./.github/workflows/release-build.yml
with:
tag: ${{ needs.prepare.outputs.tag }}
release_id: ${{ needs.prepare.outputs.release_id }}
secrets: inherit
publish:
permissions:
contents: write
needs: [prepare, binaries]
runs-on: ubuntu-latest
env:
TAG: ${{ needs.prepare.outputs.tag }}
SHA: ${{ needs.prepare.outputs.sha }}
KEEP: 14
steps:
- name: Publish the build
run: gh release edit "$TAG" --tag "$TAG" --draft=false
- name: Point the updater at it
run: |
gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
gh release view nightly >/dev/null 2>&1 ||
gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
--notes "The update manifest of the nightly builds, and the commit last built."
gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
# Failed builds' drafts go too, once they are this old.
- name: Delete old builds
run: |
gh release list --limit 200 --json tagName,createdAt --jq \
'[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
while read -r tag; do
gh release delete "$tag" --cleanup-tag --yes
done
+9 -8
Переглянути файл
@@ -1,7 +1,7 @@
name: Release build
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release
# (run by release.yml).
# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
on:
workflow_call:
inputs:
@@ -224,17 +224,18 @@ jobs:
return;
}
// Bundle suffix → updater platform keys, as tauri-action names them.
const windows = (arch, msi, nsis) => [
[msi, [`windows-${arch}`, `windows-${arch}-msi`]],
[nsis, [`windows-${arch}-nsis`]],
];
// Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
const nightly = tag.includes("-nightly.");
const windows = (arch, msi, nsis) => nightly
? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
: [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
const kinds = [
[/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
[/_arm64\.deb$/, ["linux-aarch64-deb"]],
[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
[/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
[/_amd64\.deb$/, ["linux-x86_64-deb"]],
[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
[/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
[/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
+3 -2
Переглянути файл
@@ -1,7 +1,7 @@
name: Release
on:
push:
tags: ["v*"]
tags: ["v*", "!v*-nightly.*"]
workflow_dispatch:
inputs:
tag:
@@ -23,6 +23,7 @@ env:
jobs:
# Creates (or reuses) one draft release that every platform build uploads into.
create-release:
if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
permissions:
contents: write
runs-on: ubuntu-latest
@@ -61,7 +62,7 @@ jobs:
core.setOutput("id", existing.id);
return;
}
// Prereleases are skipped: the notes span stable release to stable release.
// Nightly builds are prereleases: the notes span stable release to stable release.
const previous = releases.find((r) => !r.draft && !r.prerelease);
const { data: notes } = await github.rest.repos.generateReleaseNotes({
owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
-1
Переглянути файл
@@ -9,7 +9,6 @@
"dist",
"target",
"src/bindings.ts",
"docs/snippets/plugin-catalog.jsx",
"evals/*/golden",
"src/editor/core/cm/angular/parser*.ts",
"src/editor/core/cm/jsp/parser*.ts",
+1 -5
Переглянути файл
@@ -9,8 +9,7 @@ Visual style: dark, low-contrast greys, one cool accent
- `crates/ide-*` — backend crates; one domain each. Depend on `ide-core` for shared
types; never reach into another crate's internals.
- `src-tauri/` — glue only: `state.rs` (AppState / Project), `commands/<domain>.rs`
(desktop-only commands; the adapters of `ide-host` commands are derived), `events.rs`.
No domain logic here.
(thin typed IPC adapters), `events.rs`. No domain logic here.
- `src/bindings.ts` — generated by tauri-specta (`pnpm gen:bindings`). Never edit.
- `src/platform/` — ipc (`call`, `onIdeEvent`, `nextRequestId`), actions registry,
keymap + dispatcher, context keys / `when` clauses, project store.
@@ -34,9 +33,6 @@ Visual style: dark, low-contrast greys, one cool accent
- IPC coordinates: 0-based lines, **UTF-16** columns/offsets everywhere (`ide-core::text`).
- Every command returns `IdeResult<T>`; convert internal errors at the crate edge.
- Declare a command once, on its implementation: `#[command(trust = …)]` in `ide-host::ops`
plus its module's `domain!` list (Tauri adapter, server handler and bindings are derived);
desktop-only commands use `#[desktop_command(trust = …)]` and `desktop_domain!`.
- Streaming → `tauri::ipc::Channel<T>`; cancellable → UI-allocated `RequestId` +
`cancel_request`. Backend → UI notifications → `IdeEvent` via `EventSink`.
- Long work never blocks the UI thread or a Tauri command thread: use
Створено
+44 -73
Переглянути файл
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4235,20 +4235,9 @@ dependencies = [
"png 0.18.1",
]
[[package]]
name = "ide-command"
version = "0.1.47"
dependencies = [
"heck 0.5.0",
"proc-macro2",
"quote",
"serde",
"syn 2.0.119",
]
[[package]]
name = "ide-core"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4265,7 +4254,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-run",
@@ -4279,7 +4268,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4308,7 +4297,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4344,7 +4333,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4357,7 +4346,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4378,7 +4367,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4390,7 +4379,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4403,7 +4392,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4421,7 +4410,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4435,7 +4424,6 @@ dependencies = [
"ide-agent",
"ide-analysis",
"ide-build",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
@@ -4447,7 +4435,6 @@ dependencies = [
"ide-index",
"ide-jsonrpc",
"ide-jvm-attach",
"ide-jvm-inspect",
"ide-language",
"ide-lsp",
"ide-mcp",
@@ -4460,7 +4447,6 @@ dependencies = [
"ide-search",
"ide-spell",
"ide-ssh",
"ide-streams",
"ide-syntax",
"ide-terminal",
"ide-text",
@@ -4495,7 +4481,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4514,7 +4500,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
@@ -4536,7 +4522,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4548,7 +4534,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"encoding_rs",
"futures",
@@ -4565,7 +4551,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"libc",
"tempfile",
@@ -4574,7 +4560,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"futures",
"serde",
@@ -4585,11 +4571,10 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
"dunce",
"ide-core",
"ide-extension",
"ide-text",
@@ -4644,7 +4629,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4672,7 +4657,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"bytes",
"dunce",
@@ -4691,7 +4676,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"futures",
"ide-core",
@@ -4714,7 +4699,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4737,7 +4722,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4751,7 +4736,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"futures",
@@ -4771,7 +4756,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4795,7 +4780,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-tools",
@@ -4811,7 +4796,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"flate2",
@@ -4834,7 +4819,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"encoding_rs",
@@ -4855,7 +4840,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"parking_lot",
@@ -4868,7 +4853,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4891,22 +4876,9 @@ dependencies = [
"uuid",
]
[[package]]
name = "ide-streams"
version = "0.1.47"
dependencies = [
"ide-core",
"ide-language",
"ide-syntax",
"serde",
"serde_json",
"specta",
"tree-sitter",
]
[[package]]
name = "ide-syntax"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-language",
@@ -4921,7 +4893,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"libc",
@@ -4934,7 +4906,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4947,7 +4919,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"flate2",
"hex",
@@ -4968,7 +4940,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4989,7 +4961,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"chardetng",
"dunce",
@@ -5015,7 +4987,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5031,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -6660,7 +6632,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -6674,7 +6646,6 @@ dependencies = [
"ide-build",
"ide-cli",
"ide-clipboard",
"ide-command",
"ide-core",
"ide-coverage",
"ide-dap",
+1 -9
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.47"
version = "0.1.46"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
@@ -42,7 +42,6 @@ ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
ide-host = { path = "crates/ide-host" }
ide-command = { path = "crates/ide-command" }
ide-mcp = { path = "crates/ide-mcp" }
ide-scaffold = { path = "crates/ide-scaffold" }
ide-notebook = { path = "crates/ide-notebook" }
@@ -53,7 +52,6 @@ ide-jvm-attach = { path = "crates/ide-jvm-attach" }
ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
ide-jdwp = { path = "crates/ide-jdwp" }
ide-heap = { path = "crates/ide-heap" }
ide-streams = { path = "crates/ide-streams" }
# serialization & IPC typing
serde = { version = "1", features = ["derive"] }
@@ -125,12 +123,6 @@ uuid = { version = "1", features = ["v4"] }
keyring = "4.2"
keyring-core = "1"
# proc macros
heck = "0.5"
proc-macro2 = "1"
quote = "1"
syn = { version = "2", features = ["full"] }
# testing
insta = { version = "1", features = ["yaml"] }
proptest = "1"
+1 -1
Переглянути файл
@@ -4,7 +4,7 @@
`src/ui/brands/*.svg` use the unmodified logo paths from
[Simple Icons](https://github.com/simple-icons/simple-icons), retrieved through
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:deepseek`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
## Project Lombok
+23 -106
Переглянути файл
@@ -14,21 +14,20 @@ use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
/// session's model: they describe that model only, and other models may offer different ones.
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
match run_once(shared, spec, prefer_stored, model).await {
match run_once(shared, spec, prefer_stored).await {
Err(err)
if !prefer_stored
&& crate::provider::is_copilot_provider(&spec.id)
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
&& super::auth_required(0, &err) =>
{
let retry = run_once(shared, spec, true, model).await;
let retry = run_once(shared, spec, true).await;
if retry.is_ok() {
crate::provider::mark_prefer_stored_copilot_auth();
}
@@ -38,12 +37,7 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option
}
}
async fn run_once(
shared: &Arc<Shared>,
spec: &ProviderSpec,
strip_ambient: bool,
selected_model: Option<&str>,
) -> Result<Discovered, String> {
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
let root = shared.paths.project_root.clone();
let launch = spec.clone();
let launch = tokio::task::spawn_blocking({
@@ -53,68 +47,28 @@ async fn run_once(
.await
.map_err(|e| e.to_string())?;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
let client = Dialect::wrap(updates.clone());
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
let _stop = crate::catalogs::KillPeer(peer.clone());
let conn = Conn::new(peer.clone(), client);
let work = async {
conn.initialize(&client_info()).await.map_err(discovery_error)?;
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
let cwd_s = cwd.to_string_lossy().into_owned();
// No project MCP during discovery: Cursor can spend a long time spawning servers.
let new: Value = conn
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
.await
.map_err(discovery_error)?;
.map_err(|e| e.to_string())?;
let mut options = config::options_of(&new);
config::add_client_options(&launch.id, &mut options);
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
let mut levels = BTreeMap::new();
let has_config = new.get("configOptions").is_some_and(Value::is_array);
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
levels.insert(model.clone(), levels_for_model_from_slice(&options));
}
if let Some(selected) = selected_model
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
&& !levels.contains_key(selected)
{
let session =
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
let (method, mut params) = config::set_request(option, selected);
params["sessionId"] = json!(session);
updates.config.lock().session = Some(session.to_owned());
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
let settings = if let Some(settings) = selected_settings(&response, selected) {
Some(settings)
} else {
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
loop {
let notified = updates.changed.notified();
if let Some(settings) = updates
.config
.lock()
.options
.as_ref()
.and_then(|options| selected_settings(options, selected))
{
return settings;
}
notified.await;
}
})
.await
.ok()
};
match settings {
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
// An agent on the legacy `models` field that says nothing more: the model has
// no settings of its own, and switching to it must not fail.
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
None => return Err("The agent did not report settings for the selected model".to_owned()),
};
}
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
let levels = match (model, levels_for_model_from_slice(&options)) {
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
_ => BTreeMap::new(),
};
let commands = updates
.commands
.lock()
@@ -134,38 +88,16 @@ async fn run_once(
struct DiscoveryUpdates {
provider: String,
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
config: Mutex<DiscoveryConfig>,
changed: tokio::sync::Notify,
}
#[derive(Default)]
struct DiscoveryConfig {
session: Option<String>,
options: Option<Value>,
}
impl ide_jsonrpc::Handler for DiscoveryUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method != "session/update" {
return;
}
let Some(update) = params.get("update") else { return };
match update["sessionUpdate"].as_str() {
Some("available_commands_update") => {
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
Some("config_option_update") => {
let mut config = self.config.lock();
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
&& config.session.is_some()
&& update.get("configOptions").is_some_and(Value::is_array)
{
config.options = Some(update.clone());
self.changed.notify_one();
}
}
_ => {}
if method == "session/update"
&& let Some(update) = params.get("update")
&& update["sessionUpdate"] == "available_commands_update"
{
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
}
@@ -174,24 +106,8 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
}
}
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
match error {
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
"Sign in required: the agent could not authenticate model discovery".into()
}
other => format!("The agent could not complete model discovery: {other}"),
}
}
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
response.get("configOptions")?.as_array()?;
let options = config::options_of(response);
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
current.is_none_or(|current| current == model).then_some(options)
}
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
options
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
let levels: Vec<_> = options
.iter()
.filter(|o| config::is_per_model_option(o))
.cloned()
@@ -205,5 +121,6 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfig
}
o
})
.collect()
.collect();
(!levels.is_empty()).then_some(levels)
}
+3 -21
Переглянути файл
@@ -27,7 +27,7 @@ use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use std::sync::atomic::{AtomicU8, Ordering};
use tokio::sync::oneshot;
/// ACP's error code for a request that needs the user to sign in.
@@ -162,16 +162,9 @@ impl Negotiated {
Self { generation: 2, capabilities, agent_info: response.get("info").cloned(), auth_methods, meta }
}
/// Whether a saved session can be reopened: `loadSession`, or a v1 agent's
/// `sessionCapabilities.resume` (DeepSeek Harness), which stands in for it.
/// Whether a saved session can be reopened (`session/load` on v1, `session/resume` on v2).
pub fn load_session(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true) || self.session("resume")
}
/// Whether `session/load` must be sent as `session/resume`: a v1 agent that advertises
/// `sessionCapabilities.resume` instead of `loadSession` (DeepSeek Harness).
pub fn resume_instead_of_load(&self) -> bool {
self.capabilities.get("loadSession").and_then(Value::as_bool) != Some(true) && self.session("resume")
self.capabilities.get("loadSession").and_then(Value::as_bool) == Some(true)
}
/// `promptCapabilities.<name>` (`image`, `audio`, `embeddedContext`).
@@ -212,8 +205,6 @@ pub(crate) struct Dialect {
inner: Arc<dyn Handler>,
/// 0 until `initialize` answers; then 1 or 2.
generation: AtomicU8,
/// Set by `initialize`: a v1 agent's `session/load` is sent as `session/resume`.
resume_load: AtomicBool,
normalizer: Mutex<Normalizer>,
/// Running v2 prompts, by session id.
turns: Mutex<HashMap<String, Turn>>,
@@ -231,7 +222,6 @@ impl Dialect {
Arc::new(Self {
inner,
generation: AtomicU8::new(0),
resume_load: AtomicBool::new(false),
normalizer: Mutex::new(Normalizer::default()),
turns: Mutex::new(HashMap::new()),
})
@@ -241,10 +231,6 @@ impl Dialect {
self.generation.load(Ordering::Acquire)
}
fn resume_load(&self) -> bool {
self.resume_load.load(Ordering::Acquire)
}
fn v2(&self) -> bool {
self.generation() == 2
}
@@ -394,7 +380,6 @@ impl Conn {
let response: Value = self.peer.request("initialize", initialize_params(client_info), None).await?;
let negotiated = Negotiated::from_initialize(&response);
self.dialect.generation.store(negotiated.generation, Ordering::Release);
self.dialect.resume_load.store(negotiated.resume_instead_of_load(), Ordering::Release);
Ok(negotiated)
}
@@ -408,9 +393,6 @@ impl Conn {
let params = serde_json::to_value(params).map_err(|e| RpcError::Protocol(e.to_string()))?;
let value = if self.dialect.v2() {
self.request_v2(method, params, cancel).await?
} else if method == "session/load" && self.dialect.resume_load() {
// Same request shape, without a replay and without v2's setup translation.
self.peer.request("session/resume", params, cancel).await?
} else {
self.peer.request(method, params, cancel).await?
};
-85
Переглянути файл
@@ -180,7 +180,6 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
fn a_v2_initialize_response_reads_as_v1_capabilities() {
let n = Negotiated::from_initialize(&result(TURN, 1));
assert_eq!(n.generation, 2);
assert!(!n.resume_instead_of_load(), "v2 maps `session/load` itself");
assert!(n.load_session());
assert!(n.prompt("image") && n.prompt("embeddedContext") && !n.prompt("audio"));
assert!(n.session("fork") && n.session("resume") && n.session("close") && n.session("delete"));
@@ -682,87 +681,3 @@ fn stdio_mcp_is_v1_baseline_and_negotiated_in_v2() {
.mcp_stdio()
);
}
/// A v1 agent that answers `initialize` with `init` and records every request it gets.
/// Keeps its own `Peer` so the duplex stays open while the client sends.
struct V1Agent {
init: Value,
peer: std::sync::OnceLock<Peer>,
requests: parking_lot::Mutex<Vec<(String, Value)>>,
}
impl Handler for V1Agent {
fn on_notification(&self, _: &str, _: Value) {}
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
self.requests.lock().push((method.to_owned(), params));
Ok(if method == "initialize" { self.init.clone() } else { json!({}) })
}
}
async fn connect_v1(agent: Arc<V1Agent>) -> (Conn, Negotiated) {
let (a, b) = tokio::io::duplex(1 << 20);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let _ = agent.peer.set(Peer::connect_framed(br, bw, agent.clone(), Framing::Lines));
let dialect = Dialect::wrap(Arc::new(Recorder::default()));
let conn = Conn::new(Peer::connect_framed(ar, aw, dialect.clone(), Framing::Lines), dialect);
let n = conn.initialize(&json!({ "name": "OpenIDEA", "version": "0" })).await.unwrap();
assert_eq!((n.generation, conn.generation()), (1, 1));
(conn, n)
}
fn v1_agent(init: Value) -> Arc<V1Agent> {
Arc::new(V1Agent { init, peer: Default::default(), requests: Default::default() })
}
/// A v1 agent that advertises `sessionCapabilities.resume` instead of `loadSession`
/// (DeepSeek Harness) can reopen a saved session, but only through `session/resume`.
#[tokio::test(flavor = "multi_thread")]
async fn a_v1_agent_with_resume_instead_of_load_reopens_through_session_resume() {
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentInfo": { "name": "deepseek-harness-acp", "version": "0.0.1" },
"agentCapabilities": { "sessionCapabilities": { "close": {}, "list": {}, "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session(), "a resume-only agent is reloadable");
assert!(n.resume_instead_of_load());
assert!(n.session("resume"));
let params = json!({ "sessionId": "s1", "cwd": "/p", "mcpServers": [] });
let _: Value = conn.request("session/load", params.clone(), None).await.unwrap();
let requests = agent.requests.lock().clone();
assert_eq!(requests.iter().map(|(m, _)| m.as_str()).collect::<Vec<_>>(), ["initialize", "session/resume"]);
assert_eq!(requests[1].1, params, "same request shape as `session/load`");
}
/// Every other v1 agent is untouched: `loadSession` still sends `session/load`, and an
/// agent advertising neither capability is not treated as loadable.
#[tokio::test(flavor = "multi_thread")]
async fn v1_agents_that_do_not_advertise_resume_keep_session_load() {
for (init, loadable) in [
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": true } }), true),
(json!({ "protocolVersion": 1, "agentCapabilities": { "loadSession": false } }), false),
(json!({ "protocolVersion": 1, "agentCapabilities": { "sessionCapabilities": { "resume": null } } }), false),
(json!({ "protocolVersion": 1 }), false),
] {
let agent = v1_agent(init);
let (conn, n) = connect_v1(agent.clone()).await;
assert_eq!(n.load_session(), loadable);
assert!(!n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
// `loadSession: true` wins over a resume-only advertisement.
let agent = v1_agent(json!({
"protocolVersion": 1,
"agentCapabilities": { "loadSession": true, "sessionCapabilities": { "resume": {} } },
}));
let (conn, n) = connect_v1(agent.clone()).await;
assert!(n.load_session() && !n.resume_instead_of_load());
let _: Value = conn.request("session/load", json!({ "sessionId": "s1" }), None).await.unwrap();
let methods: Vec<String> = agent.requests.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialize", "session/load"]);
}
-80
Переглянути файл
@@ -1,80 +0,0 @@
//! Codex's asynchronous questions are answered by a user message, not a permission response.
use crate::AgentQuestion;
use ide_core::{IdeError, IdeResult};
use serde_json::json;
use std::collections::BTreeMap;
/// The wire reply and its readable record. Question ids, not wording, associate each answer.
pub(crate) fn reply(questions: &[AgentQuestion], answers: &str) -> IdeResult<(String, String)> {
let answers: BTreeMap<String, Vec<String>> =
serde_json::from_str(answers).map_err(|_| IdeError::invalid("invalid question answers"))?;
if questions.is_empty() || answers.len() != questions.len() {
return Err(IdeError::invalid("answer every question"));
}
let mut replies = Vec::new();
let mut record = Vec::new();
for question in questions {
let key = question.answer_key.as_deref().ok_or_else(|| IdeError::invalid("missing question id"))?;
let values = answers.get(key).ok_or_else(|| IdeError::invalid("missing question answer"))?;
if values.is_empty()
|| (!question.multi_select && values.len() != 1)
|| values.iter().any(|v| v.trim().is_empty())
{
return Err(IdeError::invalid("empty or invalid question answer"));
}
let answer = values.iter().map(|v| v.trim()).collect::<Vec<_>>().join(", ");
let mut title = question.question.clone();
let mut end = title.len().min(512);
while !title.is_char_boundary(end) {
end -= 1;
}
title.truncate(end);
title = title.replace(['\n', '\r'], " ");
replies.push(json!({ "questionItemId": key, "question": title, "answer": answer }));
record.push(format!("{}: {}", question.question, answer));
}
Ok((
format!("<send_user_message_question_reply>\n{}\n</send_user_message_question_reply>", json!(replies)),
record.join("\n"),
))
}
#[cfg(test)]
mod tests {
use super::*;
fn question(key: &str) -> AgentQuestion {
AgentQuestion {
answer_key: Some(key.into()),
header: String::new(),
question: "Which?".into(),
multi_select: false,
options: Vec::new(),
}
}
#[test]
fn identical_wording_keeps_answers_associated_with_ids() {
let (wire, record) =
reply(&[question("first"), question("second")], r#"{"first":[" One "],"second":["Two"]}"#).unwrap();
let body = wire
.strip_prefix("<send_user_message_question_reply>\n")
.unwrap()
.strip_suffix("\n</send_user_message_question_reply>")
.unwrap();
let replies: serde_json::Value = serde_json::from_str(body).unwrap();
assert_eq!(replies[0], json!({"questionItemId":"first","question":"Which?","answer":"One"}));
assert_eq!(replies[1]["answer"], "Two");
assert_eq!(record, "Which?: One\nWhich?: Two");
}
#[test]
fn malformed_missing_and_empty_answers_are_rejected() {
for answers in
["no", "{}", r#"{"other":["One"]}"#, r#"{"first":[]}"#, r#"{"first":[" "]}"#, r#"{"first":["One","Two"]}"#]
{
assert!(reply(&[question("first")], answers).is_err(), "{answers}");
}
}
}
+21 -138
Переглянути файл
@@ -45,18 +45,9 @@ struct Entry {
error: Option<String>,
flight: Option<watch::Receiver<bool>>,
abort: Option<tokio::task::AbortHandle>,
flight_model: Option<String>,
requested_model: Option<String>,
model_failures: HashMap<String, ModelFailure>,
catalog: Option<CatalogData>,
}
struct ModelFailure {
completed: Instant,
retry_at_ms: f64,
error: String,
}
#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CatalogData {
@@ -213,24 +204,6 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
{
return catalog.thought_levels.get(model).cloned();
}
drop(state);
let cache = shared.known.lock();
let known = cache.get(provider)?;
known
.catalogs
.get(&shared.root_key())
.map(|saved| &saved.catalog.thought_levels)
.unwrap_or(&known.thought_levels)
.get(model)
.cloned()
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
@@ -241,27 +214,16 @@ impl AgentCatalogs {
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
let unknown_model = entry
.requested_model
.as_deref()
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
AgentModelCatalog {
provider: provider.to_owned(),
config: shared.config_for_new_task(catalog.config, provider),
thought_levels: catalog.thought_levels,
refreshing: entry.flight.is_some(),
refreshed_at_ms: catalog.refreshed_at_ms,
retry_at_ms: model_failure
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
.map(|failure| failure.retry_at_ms)
.or_else(|| {
(!unknown_model)
.then_some(entry.retry_at_ms)
.flatten()
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
}),
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
retry_at_ms: entry
.retry_at_ms
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
error: entry.error.clone(),
}
}
@@ -271,7 +233,6 @@ impl AgentCatalogs {
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
force: bool,
model: Option<&str>,
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
let key = Self::key(shared, &spec.id);
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
@@ -303,7 +264,6 @@ impl AgentCatalogs {
let mut catalog = saved.catalog;
if !matching {
catalog.refreshed_at_ms = None;
catalog.thought_levels.clear();
}
catalog
});
@@ -319,73 +279,31 @@ impl AgentCatalogs {
error: None,
flight: None,
abort: None,
flight_model: None,
requested_model: None,
model_failures: HashMap::new(),
},
);
}
let fallback =
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
state.generation += 1;
let generation = state.generation;
let entry = state.entries.get_mut(&key).expect("catalog entry");
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
let target = model
.filter(|model| {
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|| (!fresh && catalog.model_option().is_none())
})
.map(str::to_owned);
if model.is_some() && entry.requested_model.as_deref() != model {
entry.requested_model = model.map(str::to_owned);
}
let superseded = model.is_some()
&& entry.flight.is_some()
&& (entry.flight_model.is_some() || target.is_some())
&& entry.flight_model.as_deref() != target.as_deref();
if superseded {
if let Some(abort) = entry.abort.take() {
abort.abort();
}
entry.flight = None;
entry.generation = generation;
entry.flight_model = None;
}
let cooling = match target.as_ref() {
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
};
let eligible = !cooling && (target.is_some() || force || !fresh);
let mut start = None;
if entry.flight.is_none() && eligible {
if entry.flight.is_none() && !cooling && (force || !fresh) {
let (done, ready) = watch::channel(false);
entry.flight = Some(ready);
entry.flight_model = target.clone();
entry.error = None;
if let Some(model) = target.as_ref() {
entry.model_failures.remove(model);
}
entry.retry_at_ms = None;
// Every flight has its own generation, including superseded model selections.
entry.generation = generation;
start = Some((entry.generation, target, done));
start = Some((entry.generation, done));
}
let snapshot = self.snapshot(shared, &spec.id, entry);
let flight = entry.flight.clone();
drop(state);
if superseded && start.is_none() {
self.broadcast(shared, &snapshot);
}
if let Some((generation, model, done)) = start {
if let Some((generation, done)) = start {
self.broadcast(shared, &snapshot);
let coordinator = self.clone();
let shared = shared.clone();
let flight_key = key.clone();
let task = shared.runtime.clone().spawn(async move {
let result = discover(&shared, spec, model.as_deref()).await;
coordinator.complete(&shared, flight_key, generation, model, result);
let result = discover(&shared, spec).await;
coordinator.complete(&shared, flight_key, generation, result);
let _ = done.send(true);
});
// A subscriber can re-enter and change configuration during the start event.
@@ -401,14 +319,7 @@ impl AgentCatalogs {
(snapshot, flight)
}
fn complete(
&self,
shared: &Shared,
key: Key,
generation: u64,
model: Option<String>,
result: Result<Discovered, String>,
) {
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
.into_iter()
.find(|spec| spec.id == key.2)
@@ -419,7 +330,6 @@ impl AgentCatalogs {
if current.as_ref() != Some(&entry.context) {
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
entry.completed = None;
entry.retry_at_ms = None;
entry.error = None;
@@ -430,16 +340,12 @@ impl AgentCatalogs {
return;
}
let now = self.now();
if model.is_none() {
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
}
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
let success = match result {
Ok(found) => {
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
let mut cache = shared.known.lock();
let known = cache.entry(key.2.clone()).or_default();
let mut catalog = CatalogData {
@@ -448,7 +354,7 @@ impl AgentCatalogs {
refreshed_at_ms: Some(self.epoch_ms()),
};
// Efforts sessions reported for models discovery doesn't read stay while listed.
for (model, levels) in previous.thought_levels {
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
catalog.thought_levels.insert(model, levels);
}
@@ -467,30 +373,11 @@ impl AgentCatalogs {
entry.catalog = Some(catalog);
shared.persist_known(&cache);
entry.successful = Some(now);
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.model_failures.retain(|model, _| {
entry
.catalog
.as_ref()
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
});
entry.error = None;
true
}
Err(error) => {
if let Some(model) = model {
entry.model_failures.insert(
model,
ModelFailure {
completed: now,
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
error,
},
);
} else {
entry.error = Some(error);
}
entry.error = Some(error);
false
}
};
@@ -561,22 +448,18 @@ impl AgentCatalogs {
impl crate::AgentManager {
/// Return cached choices immediately and schedule discovery when eligible.
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
// Settings and environment secrets can change while this window is open.
*self.shared.providers.write() =
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
}
}
async fn discover(
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
model: Option<&str>,
) -> Result<Discovered, String> {
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
match spec.driver {
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
provider::Driver::Claude => {
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
@@ -601,7 +484,7 @@ async fn discover(
provider::Driver::Copilot => {
if shared.uses_copilot_acp_fallback(&spec) {
let acp_spec = native::copilot::acp_fallback_spec(&spec);
return acp::discover::run(shared, &acp_spec, model).await;
return acp::discover::run(shared, &acp_spec).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
@@ -630,7 +513,7 @@ async fn discover(
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec, model).await
acp::discover::run(shared, &acp_spec).await
}
Err(err) => Err(err.message),
}
+56 -372
Переглянути файл
@@ -11,10 +11,8 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
notifications: mpsc::UnboundedSender<Value>,
}
struct Harness {
@@ -33,10 +31,6 @@ impl Drop for Live {
impl Harness {
fn new() -> Self {
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
}
fn with_initialize(initialize: Value) -> Self {
let (pending_tx, pending) = mpsc::unbounded_channel();
let launches = Arc::new(AtomicUsize::new(0));
let live = Arc::new(AtomicUsize::new(0));
@@ -48,53 +42,26 @@ impl Harness {
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
let initialize = initialize.clone();
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
let (client_io, server_io) = tokio::io::duplex(1 << 16);
let (read, mut write) = tokio::io::split(server_io);
tokio::spawn(async move {
let _guard = guard;
let mut lines = BufReader::new(read).lines();
loop {
let line = tokio::select! {
line = lines.next_line() => match line.unwrap() {
Some(line) => line,
None => break,
},
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
break;
}
continue;
}
};
while let Some(line) = lines.next_line().await.unwrap() {
let request: Value = serde_json::from_str(&line).unwrap();
let id = &request["id"];
if id.is_null() {
continue;
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
notifications: notifications_tx.clone(),
})
.unwrap();
let result = loop {
tokio::select! {
result = &mut result => break result.unwrap(),
_ = lines.next_line() => return,
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
return;
}
}
}
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
"session/new" => {
let (reply, result) = oneshot::channel();
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
let result = tokio::select! {
result = result => result.unwrap(),
_ = lines.next_line() => break,
};
match result {
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
@@ -223,7 +190,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
let mut events = events(&manager);
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert!(cached.refreshing);
assert_eq!(model_values(&cached), ["old", "retained"]);
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
@@ -237,13 +204,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
assert_eq!(provider.config, fresh.config);
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
@@ -262,7 +229,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
let catalogs = Arc::new(AgentCatalogs::default());
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
completed(&mut events).await;
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
@@ -274,16 +241,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
};
let catalog = manager.refresh_models(PROVIDER, false, None).unwrap();
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap();
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
// Discovery again reads "first" only; "second" keeps what its session reported.
advance(&catalogs, 60);
while events.try_recv().is_ok() {}
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
let fresh = completed(&mut events).await;
assert_eq!(efforts(&fresh, "first"), ["medium"]);
@@ -306,7 +273,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(model_values(&cached), ["legacy"]);
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
@@ -325,11 +292,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
let pending = harness.next().await;
for _ in 0..10 {
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
}
let commands = tokio::spawn({
let first = first.clone();
@@ -342,21 +309,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
assert_eq!(completed(&mut second_events).await, done);
commands.await.unwrap().unwrap();
for force in [false, true, false, true] {
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
}
advance(&catalogs, 29);
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
let newer = completed(&mut first_events).await;
assert_eq!(model_values(&newer), ["two"]);
assert_eq!(completed(&mut second_events).await, newer);
advance(&catalogs, 15 * 60 - 1);
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
advance(&catalogs, 1);
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
completed(&mut first_events).await;
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -370,25 +337,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
let success = completed(&mut events).await;
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
advance(&catalogs, 15 * 60);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, success.config);
assert_eq!(failed.thought_levels, success.thought_levels);
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 29);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
let recovered = completed(&mut events).await;
assert_eq!(model_values(&recovered), ["recovered"]);
@@ -403,21 +370,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let pending = harness.next().await;
tokio::time::pause();
tokio::time::advance(Duration::from_secs(4)).await;
let failed = completed(&mut events).await;
assert!(failed.error.as_deref().unwrap().contains("time"));
assert!(failed.retry_at_ms.is_some());
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
tokio::time::resume();
stopped(&harness).await;
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
assert!(pending.reply.is_closed());
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
completed(&mut events).await;
}
@@ -431,16 +398,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "two");
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
let latest = harness.next().await;
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
let shown = first.refresh_models(PROVIDER, false).unwrap();
assert_eq!(shown.config, fresh.config);
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
assert!(!shown.refreshing);
@@ -448,7 +415,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
// A changed configuration also invalidates successful freshness/cooldown.
configure(tmp.path(), "three");
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
completed(&mut events).await;
}
@@ -458,7 +425,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
let tmp = tempfile::tempdir().unwrap();
let harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
assert!(manager.refresh_models("missing-provider", true, None).is_err());
assert!(manager.refresh_models("missing-provider", true).is_err());
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
}
@@ -470,18 +437,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs, &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let latest = harness.next().await;
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -501,18 +468,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
let second = make_manager_at(&b, &models_file, catalogs, &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
let a_catalog = completed(&mut first_events).await;
second.refresh_models(PROVIDER, false, None).unwrap();
second.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
let b_catalog = completed(&mut second_events).await;
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
let cached = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!cached.refreshing, "matching persisted context should retain freshness");
assert_eq!(cached.config, expected.config);
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
@@ -521,7 +488,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
configure(&a, "new-account");
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
let mut events = events(&changed);
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
let stale = changed.refresh_models(PROVIDER, false).unwrap();
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
assert!(stale.refreshed_at_ms.is_none());
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
@@ -538,7 +505,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "after");
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
@@ -546,7 +513,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
assert!(model_values(&discarded).is_empty());
assert!(discarded.refreshed_at_ms.is_none());
assert!(!tmp.path().join("models.json").exists());
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
}
@@ -559,296 +526,13 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
let empty = completed(&mut events).await;
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
}
fn selected_response(model: &str, effort: &[&str]) -> Value {
let mut result = response(&[model], effort);
if effort.is_empty() {
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
}
result
}
fn config_notification(session: &str, result: &Value) -> Value {
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": session,
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
} })
}
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
catalog.thought_levels[model]
.iter()
.filter(|option| option.category.as_deref() == Some("thought_level"))
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
.collect()
}
#[tokio::test]
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
let models = ["default", "second", "plain", "unknown"];
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let original = completed(&mut events).await;
assert!(!original.thought_levels.contains_key("second"));
// A fresh catalog and its global cooldown must not delay an unknown selection.
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let pending = harness.next().await;
assert_eq!(pending.method, "session/set_config_option");
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
let mut second = selected_response("second", &["off", "auto", "max"]);
second["configOptions"].as_array_mut().unwrap().push(json!({
"id": "context_tier", "type": "select", "currentValue": "large",
"options": [{ "value": "normal" }, { "value": "large" }]
}));
pending.reply.send(Ok(second)).unwrap();
let learned = completed(&mut events).await;
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
assert!(!learned.thought_levels.contains_key("unknown"));
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
let plain = completed(&mut events).await;
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
for model in ["default", "second", "plain"] {
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
}
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
assert!(!cached.refreshing);
assert!(cached.thought_levels["plain"].is_empty());
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
}
#[tokio::test]
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
let models = ["default", "unsupported", "other"];
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let original = completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(reply).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, original.config);
assert!(!failed.thought_levels.contains_key("unsupported"));
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
// The failed model cannot block another model, and its cooldown survives that success.
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
assert!(completed(&mut events).await.error.is_none());
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
let retried = completed(&mut events).await;
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
assert!(retried.error.is_none());
}
}
#[tokio::test]
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&first);
let models = ["default", "second", "third"];
first.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
completed(&mut events).await;
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let obsolete = harness.next().await;
for _ in 0..5 {
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
}
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let current = harness.next().await;
assert_eq!(current.params["value"], "third");
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
stopped(&harness).await;
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
assert_eq!(cached, fresh);
assert_eq!(efforts(&cached, "third"), ["max"]);
assert!(!cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
}
#[tokio::test]
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let obsolete = harness.next().await;
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(!known.refreshing);
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
let _ = obsolete.reply.send(Err("late failure".into()));
stopped(&harness).await;
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
// No cache is needed: the selected model is resolved in the same short-lived session.
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
let notifications = selected.notifications;
selected.reply.send(Ok(json!({}))).unwrap();
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
notifications
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
.unwrap();
let catalog = completed(&mut events).await;
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
}
#[tokio::test]
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.error.is_none(), "{:?}", catalog.error);
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
}
#[tokio::test]
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
let replaced = completed(&mut events).await;
assert_eq!(model_values(&replaced), ["default", "new"]);
assert_eq!(efforts(&replaced, "default"), ["medium"]);
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
}
#[tokio::test]
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
}));
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let mut initial = response(&["default", "second"], &["low"]);
for option in initial["configOptions"].as_array_mut().unwrap() {
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
}
harness.next().await.reply.send(Ok(initial)).unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_config_option");
assert_eq!(
selected.params,
json!({
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
})
);
// Notifications may arrive before the request response as well as after it.
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.thought_levels["second"].is_empty());
assert_eq!(efforts(&catalog, "default"), ["low"]);
}
+43 -256
Переглянути файл
@@ -8,7 +8,6 @@
//! next prompt when the agent supports `session/load`.
mod acp;
mod async_questions;
mod catalogs;
mod config;
mod conversation;
@@ -223,24 +222,11 @@ impl Shared {
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
let off = Self::mcp_off(&configured, provider, overrides);
McpForSession { servers, off }
}
fn mcp_servers_off_for_session(&self, provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
Self::mcp_off(&configured, provider, overrides)
}
fn mcp_off(configured: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut off = mcp::servers_off(configured, provider, overrides);
if overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false) {
let mut off = mcp::servers_off(&configured, overrides);
if builtin_off {
off.push(BUILTIN_SERVER.to_owned());
off.push(mcp::BUILTIN_MCP_NAME.to_owned());
off.sort();
off.dedup();
}
off
McpForSession { servers, off }
}
fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
@@ -377,7 +363,6 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
model_choice: u64,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
@@ -416,15 +401,11 @@ struct Task {
live: Mutex<Option<Live>>,
/// Serializes starting the agent.
connecting: tokio::sync::Mutex<()>,
/// Serializes replies from multiple windows to the same async question.
answering_questions: tokio::sync::Mutex<()>,
/// Unanswered permission requests: where to send the chosen option id.
permissions: Mutex<HashMap<u32, std::sync::mpsc::Sender<Option<String>>>>,
next_permission: AtomicU32,
/// Set while `session/load` replays history we already have.
replaying: AtomicBool,
/// The saved session failed to load and the user was told: the next start opens a new one.
start_fresh: AtomicBool,
/// The current turn is being cancelled to send the first queued message right away.
send_now: AtomicBool,
/// The user stopped the current turn. A stop that reaches the agent before it took the
@@ -640,7 +621,7 @@ impl AgentManager {
.into_iter()
.find(|spec| spec.id == provider)
{
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
@@ -940,50 +921,29 @@ impl AgentManager {
Ok(item)
}
/// Sends queued message `queued` now: into the running turn when the agent takes
/// messages mid-turn, else next, cancelling the current turn if there is one.
pub async fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
/// Sends queued message `queued` next, cancelling the current turn if there is one.
pub fn send_queued_now(&self, id: &str, queued: &str) -> IdeResult<()> {
let task = self.task(id)?;
let (item, busy) = {
let idle = {
let mut s = task.state.lock();
let i =
s.task.queue.iter().position(|q| q.id == queued).ok_or_else(|| IdeError::not_found("already sent"))?;
let item = s.task.queue.remove(i);
let busy = s.busy;
if !busy {
if s.busy {
s.task.queue.insert(0, item);
None
} else {
s.busy = true;
Some(item)
}
(item, busy)
};
task.persist();
task.emit_task();
if !busy {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
return Ok(());
}
// Out of the queue while it is steered, so the turn ending meanwhile doesn't send it twice.
let prompt = match task.steer(item.prompt).await {
Ok(()) => return Ok(()),
Err(prompt) => prompt,
};
let start = {
let mut s = task.state.lock();
if s.busy {
s.task.queue.insert(0, AgentQueued { id: item.id, prompt });
None
} else {
// The turn ended while steering was tried: nothing is left to interrupt.
s.busy = true;
Some(prompt)
}
};
match start {
Some(prompt) => {
self.shared.runtime.spawn(async move { task.run(prompt).await });
match idle {
Some(item) => {
self.shared.runtime.spawn(async move { task.run(item.prompt).await });
}
None => {
task.persist();
task.emit_task();
task.send_now.store(true, Ordering::Release);
task.cancel();
}
@@ -994,36 +954,19 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let (target, model_choice, previous_levels) = {
let mut s = task.state.lock();
let target = s
.task
.config
.iter()
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
let target = {
let s = task.state.lock();
let o =
s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?;
if !o.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
}
if target.category.as_deref() == Some("model") {
s.model_choice += 1;
}
let previous_levels =
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
} else {
None
};
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, s.model_choice, previous_levels)
o.clone()
};
let previous = target.current.clone();
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
// choice first so the switch and slider move immediately.
apply_config_choice(&task, option, &value);
task.persist();
task.emit_task();
@@ -1033,77 +976,36 @@ impl AgentManager {
let mut model_options = (target.category.as_deref() != Some("model")
|| previous.as_deref() == Some(value.as_str()))
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
if live.is_none()
&& target.category.as_deref() == Some("model")
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
{
let provider = task.state.lock().task.provider.clone();
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
let mut error = None;
if levels.is_none()
&& let Some(spec) = self.shared.spec(&provider)
{
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
error = catalog.error;
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
}
// Another selection may have superseded this discovery while it was waiting.
if task.state.lock().model_choice != model_choice {
return Ok(());
}
let Some(levels) = levels else {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
));
};
let mut s = task.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
s.task.config.retain(|o| !config::is_per_model_option(o));
s.task.config.extend(levels);
model_options = true;
}
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
let reply: Value = match live.peer.request(method, params, None).await {
Ok(reply) => reply,
Err(e) => {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
{
let mut s = task.state.lock();
s.wanted.retain(|c| c.id != option);
if let Some(prev) = previous.clone() {
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev });
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = previous.clone();
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
}
task.persist();
task.emit_task();
return Err(IdeError::internal(task.describe(e)));
}
};
if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice {
return Ok(());
}
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut task.state.lock().task.config, options);
model_options = true;
} else if target.category.as_deref() == Some("model") {
// Old model controls were removed above, so these came from an update
// that preceded the response.
model_options = task.state.lock().task.config.iter().any(config::is_per_model_option);
}
}
{
let mut s = task.state.lock();
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
return Ok(());
}
if !model_options && target.category.as_deref() == Some("model") {
if !model_options {
s.task.config.retain(|o| !config::is_per_model_option(o));
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
@@ -1414,53 +1316,6 @@ impl AgentManager {
}
}
/// Replies to a non-blocking question without interrupting the agent's current turn.
pub async fn answer_question(&self, id: &str, question: &str, answer: Option<String>) -> IdeResult<()> {
let task = self.task(id)?;
let _answering = task.answering_questions.lock().await;
let questions = {
let s = task.state.lock();
s.conversation
.main
.entries
.iter()
.find_map(|entry| match entry {
AgentEntry::Question { id, questions, chosen: None, .. } if id == question => {
Some(questions.clone())
}
_ => None,
})
.ok_or_else(|| IdeError::not_found("the question was already answered"))?
};
let chosen = match answer {
None => "Skipped".to_owned(),
Some(answer) => {
let (text, record) = async_questions::reply(&questions, &answer)?;
let prompt = AgentPrompt { text, files: Vec::new(), images: Vec::new() };
if let Err(prompt) = task.steer(prompt).await {
if task.state.lock().busy {
return Err(IdeError::unavailable("the reply could not join the running turn; try again"));
}
self.prompt(id, prompt, false).await?;
}
record
}
};
let changed = {
let mut s = task.state.lock();
s.conversation.main.entries.iter_mut().enumerate().find_map(|(index, entry)| match entry {
AgentEntry::Question { id, chosen: current, .. } if id == question => {
*current = Some(chosen.clone());
Some((None, index))
}
_ => None,
})
};
task.mark_dirty(changed);
task.persist();
Ok(())
}
/// Stops the agent and moves the task to Archived; its worktree stays.
pub fn archive(&self, id: &str) -> IdeResult<()> {
let task = self.task(id)?;
@@ -1704,26 +1559,6 @@ impl AgentManager {
Ok(out)
}
/// Recycles idle resumable live sessions (or schedules reload after the running turn) when
/// global, workspace, or built-in IDE MCP server settings change.
pub fn notify_mcp_servers_changed(&self) {
let tasks: Vec<Arc<Task>> = self.tasks.read().values().cloned().collect();
for task in tasks {
let (archived, busy, has_bg) = {
let s = task.state.lock();
(s.task.status == AgentStatus::Archived, s.busy, !s.background_tasks.is_empty())
};
if archived {
continue;
}
if busy || has_bg || !task.permissions.lock().is_empty() {
task.mcp_reload_pending.store(true, Ordering::Release);
} else {
task.recycle_resumable_session();
}
}
}
/// Stops every agent (project closed).
pub fn shutdown(&self) {
for task in self.tasks.read().values() {
@@ -1748,7 +1583,6 @@ impl Task {
session_id: file.session_id,
conversation,
wanted: file.wanted,
model_choice: 0,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
@@ -1759,11 +1593,9 @@ impl Task {
}),
live: Mutex::new(None),
connecting: tokio::sync::Mutex::new(()),
answering_questions: tokio::sync::Mutex::new(()),
permissions: Mutex::new(HashMap::new()),
next_permission: AtomicU32::new(1),
replaying: AtomicBool::new(false),
start_fresh: AtomicBool::new(false),
send_now: AtomicBool::new(false),
cancel_pending: AtomicBool::new(false),
turn_started: AtomicBool::new(false),
@@ -2326,16 +2158,9 @@ impl Task {
saved: Option<String>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
.await
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
spec.args.push("--disable-mcp-server".into());
spec.args.push(name);
}
}
self.stderr.lock().clear();
self.config_sent.lock().clear();
let weak = Arc::downgrade(self);
@@ -2372,8 +2197,7 @@ impl Task {
let mut tried_auth = false;
let mut session = None;
let start_fresh = self.start_fresh.load(Ordering::Acquire);
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
if let (Some(id), true) = (saved, can_load) {
self.replaying.store(true, Ordering::Release);
let mut params = session_params(&cwd_s, &mcp_servers);
params["sessionId"] = json!(&id);
@@ -2382,23 +2206,7 @@ impl Task {
self.replaying.store(false, Ordering::Release);
match loaded {
Ok(v) => session = Some((id, v)),
// Not silently: a new session would lose the conversation and replace the saved id.
Err(e) => {
tracing::info!("agent task {}: session/load failed: {e}", self.id);
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
return Err(SessionOpenError { message, allow_acp_fallback: false });
}
self.start_fresh.store(true, Ordering::Release);
return Err(SessionOpenError {
message: format!(
"Couldn't reopen this conversation's {} session: {}\n\nSend the message again to \
continue in a new session. The agent won't see the earlier conversation.",
spec.name,
self.describe(e)
),
allow_acp_fallback: false,
});
}
Err(e) => tracing::info!("agent task {}: session/load failed, starting a new session: {e}", self.id),
}
}
let resumed = session.is_some();
@@ -2503,7 +2311,6 @@ impl Task {
s.task.config = options;
s.task.capabilities = capabilities;
s.session_id = Some(session_id.clone());
self.start_fresh.store(false, Ordering::Release);
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
@@ -2727,7 +2534,7 @@ impl Task {
let applied = self.state.lock().conversation.apply(session, update, now_ms());
self.mark_dirty(applied);
// A subagent can start or finish after the turn that started it: saved right away.
if matches!(kind, "subagent_update" | "user_question") {
if kind == "subagent_update" {
self.persist();
}
}
@@ -3114,7 +2921,7 @@ fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
});
}
for i in &prompt.images {
out.push(json!({ "type": "image", "mimeType": i.media_type(), "data": i.data }));
out.push(json!({ "type": "image", "mimeType": i.mime_type, "data": i.data }));
}
out
}
@@ -3286,32 +3093,12 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
})
}
fn restore_config_choice(
task: &Task,
target: &AgentConfigOption,
value: &str,
previous: Option<&str>,
model_choice: u64,
previous_levels: Option<Vec<AgentConfigOption>>,
) {
let option = target.id.as_str();
let is_model = target.category.as_deref() == Some("model");
fn apply_config_choice(task: &Task, option: &str, value: &str) {
let mut s = task.state.lock();
if (is_model && s.model_choice != model_choice)
|| !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value))
{
return;
}
s.wanted.retain(|c| c.id != option);
if let Some(previous) = previous {
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
}
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = previous.map(str::to_owned);
}
if let Some(levels) = previous_levels {
s.task.config.retain(|o| !config::is_per_model_option(o));
s.task.config.extend(levels);
o.current = Some(value.to_owned());
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
}
+20 -67
Переглянути файл
@@ -10,7 +10,7 @@ use crate::{
};
use ide_core::IpcPath;
use serde_json::{Value, json};
use std::collections::{BTreeMap, BTreeSet, HashSet};
use std::collections::{BTreeMap, HashSet};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
@@ -89,61 +89,24 @@ fn matches_agent(agents: &[String], provider: &str) -> bool {
/// The configured servers off for this session: off by default and not switched on for it, or
/// switched off for it. Named so an agent that also loads its own configuration can keep a
/// same-named server of it off too. Workspace entries take precedence, as in [`acp_mcp_servers`].
pub(crate) fn servers_off(all: &[McpServer], provider: &str, overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen_configured = HashSet::new();
let mut enabled_names = HashSet::new();
let mut off = BTreeSet::new();
let ordered = all
.iter()
.filter(|s| s.scope == McpScope::Workspace && !s.unapproved)
.chain(all.iter().filter(|s| s.scope == McpScope::User));
for srv in ordered {
if !seen_configured.insert(srv.name.as_str()) {
continue;
}
let explicit = overrides.get(&srv.name).copied();
let matches = explicit == Some(true) || matches_agent(&srv.agents, provider);
let active = explicit.unwrap_or(srv.enabled) && matches;
if active {
enabled_names.insert(srv.name.as_str());
} else {
off.insert(srv.name.clone());
}
}
for srv in all.iter().filter(|s| s.scope == McpScope::Workspace && s.unapproved) {
if !enabled_names.contains(srv.name.as_str()) {
off.insert(srv.name.clone());
}
}
pub(crate) fn servers_off(all: &[McpServer], overrides: &BTreeMap<String, bool>) -> Vec<String> {
let mut seen = HashSet::new();
let ordered =
all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
let configured: Vec<String> = ordered
.filter(|s| seen.insert(s.name.as_str()))
.filter(|s| !overrides.get(&s.name).copied().unwrap_or(s.enabled))
.map(|s| s.name.clone())
.collect();
// A server switched off that the IDE doesn't configure may still be the agent's own.
for (name, &on) in overrides {
if !on && name.as_str() != BUILTIN_MCP_NAME && !enabled_names.contains(name.as_str()) {
off.insert(name.clone());
}
}
off.into_iter().collect()
}
/// Names of MCP servers present in Codex's own TOML configuration files (`~/.codex/config.toml`
/// and `<workspace_root>/.codex/config.toml`).
pub(crate) fn codex_external_server_names(home_dir: Option<&Path>, workspace_root: &Path) -> BTreeSet<String> {
let mut names = BTreeSet::new();
let mut paths = Vec::new();
if let Some(home) = home_dir {
paths.push(home.join(".codex").join("config.toml"));
}
paths.push(workspace_root.join(".codex").join("config.toml"));
for path in paths {
if let Ok(text) = std::fs::read_to_string(&path) {
names.extend(parse_codex_toml_servers(&text).into_keys());
}
}
names
let switched = overrides
.iter()
.filter(|(name, on)| !**on && name.as_str() != BUILTIN_MCP_NAME && !seen.contains(name.as_str()))
.map(|(name, _)| name.clone());
let mut off: Vec<String> = configured.into_iter().chain(switched).collect();
off.sort();
off.dedup();
off
}
/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
@@ -1095,11 +1058,6 @@ mod tests {
#[test]
fn servers_off_follow_the_effective_state() {
let mut claude_only = configured("claude-only", McpScope::User, true);
claude_only.agents = vec!["claude".into()];
let mut unapproved_ws = configured("unapproved-ws", McpScope::Workspace, false);
unapproved_ws.unapproved = true;
let all = [
configured("default-off", McpScope::User, false),
configured("switched-on", McpScope::User, false),
@@ -1108,8 +1066,6 @@ mod tests {
// The workspace entry decides for its name.
configured("both", McpScope::User, true),
configured("both", McpScope::Workspace, false),
claude_only,
unapproved_ws,
];
let overrides = BTreeMap::from([
("switched-on".to_owned(), true),
@@ -1117,11 +1073,8 @@ mod tests {
("agent-own".to_owned(), false),
(BUILTIN_MCP_NAME.to_owned(), false),
]);
assert_eq!(
servers_off(&all, "copilot", &overrides),
["agent-own", "both", "claude-only", "default-off", "switched-off", "unapproved-ws"]
);
assert_eq!(servers_off(&all[2..4], "copilot", &BTreeMap::new()), Vec::<String>::new());
assert_eq!(servers_off(&all, &overrides), ["agent-own", "both", "default-off", "switched-off"]);
assert_eq!(servers_off(&all[2..4], &BTreeMap::new()), Vec::<String>::new());
}
#[test]
-24
Переглянути файл
@@ -281,22 +281,6 @@ pub struct AgentImage {
pub name: Option<String>,
}
impl AgentImage {
/// The type the bytes are in. Agents reject an image whose declared type doesn't match its
/// bytes, and a pasted image's declared type can be wrong (a browser's JPEG or WebP copied as
/// `image/png`). Falls back to `mime_type` for formats not recognised here.
pub fn media_type(&self) -> &str {
let head = crate::acp::normalize_base64(&self.data[..self.data.len().min(16)]);
match head.as_slice() {
[0x89, b'P', b'N', b'G', ..] => "image/png",
[0xFF, 0xD8, 0xFF, ..] => "image/jpeg",
[b'G', b'I', b'F', b'8', ..] => "image/gif",
[b'R', b'I', b'F', b'F', _, _, _, _, b'W', b'E', b'B', b'P', ..] => "image/webp",
_ => &self.mime_type,
}
}
}
/// A message to the agent: text, plus files to look at and images.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -469,14 +453,6 @@ pub enum AgentEntry {
Agent {
text: String,
},
/// A question that can be answered while the agent keeps working, or after the turn ends.
Question {
id: String,
title: String,
questions: Vec<AgentQuestion>,
/// The submitted answers, or `Skipped`; `None` while unanswered.
chosen: Option<String>,
},
Thought {
text: String,
},
-5
Переглянути файл
@@ -1028,11 +1028,6 @@ impl CodexShim {
}
Some(t.chunk(kind, &id, &text))
});
if ty == "agentMessage"
&& let Some(update) = translate::question_update(item)
{
self.emit(thread, update);
}
}
"subAgentActivity" => {
let child = item.get("agentThreadId").and_then(Value::as_str).unwrap_or_default();
-61
Переглянути файл
@@ -473,56 +473,6 @@ fn history_replays_turns() {
assert_eq!(updates[4]["status"], "completed");
}
#[test]
fn history_preserves_async_questions_with_stable_answer_ids() {
let updates = history(
&json!({"turns": [{"items": [{
"type": "agentMessage", "id": "call-1", "text": "Which?",
"questions": [{"title": "Which?", "options": ["One", "Two"]}, {"title": "Why?"}]
}]}]}),
None,
);
let asked = updates.iter().find(|u| u["sessionUpdate"] == "user_question").expect("question update");
assert_eq!(asked["id"], "call-1");
assert_eq!(asked["questions"][0]["answerKey"], r#"["request_user_input_async","call-1",0]"#);
assert_eq!(asked["questions"][0]["options"][1]["label"], "Two");
assert_eq!(asked["questions"][1]["options"], json!([]));
}
#[tokio::test]
async fn completing_a_streamed_message_still_delivers_its_async_questions() {
let shim = Arc::new(CodexShim {
runtime: tokio::runtime::Handle::current(),
codex: OnceLock::new(),
client: OnceLock::new(),
state: Mutex::default(),
models: tokio::sync::Mutex::new(None),
skills: tokio::sync::Mutex::new(()),
});
shim.state.lock().threads.insert("thread".into(), Thread::default());
let client = Arc::new(Client::default());
let peer = crate::native::serve(shim.clone(), client.clone());
shim.text("thread", &json!({"itemId":"call-1","delta":"Which?"}), "agent_message_chunk", false);
shim.item(
"thread",
&json!({"type":"agentMessage","id":"call-1","text":"Which?",
"questions":[{"title":"Which?","options":["One","Two"]}]}),
true,
);
tokio::time::timeout(Duration::from_secs(2), async {
while client.of("thread").len() < 2 {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
assert_eq!(client.text("thread", "agent_message_chunk"), "Which?");
assert!(client.of("thread").iter().any(|u| u["sessionUpdate"] == "user_question"));
assert!(client.asked.lock().is_empty(), "an asynchronous question must not block on a permission response");
peer.kill();
shim.client.get().unwrap().kill();
}
// ---- Transcripts ---------------------------------------------------------------------
/// The ACP client: records updates and answers permission requests in order.
@@ -1721,17 +1671,6 @@ fn session_mcp_servers_become_thread_configuration() {
json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
)
);
let external = std::collections::BTreeSet::from(["linear".to_owned()]);
assert_eq!(
super::translate::mcp_config_with_external(
&json!({
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": ["linear", "not-in-codex"] } }
}),
&external,
),
Some(json!({ "mcp_servers": { "linear": { "enabled": false } } }))
);
}
#[tokio::test(flavor = "multi_thread")]
+1 -53
Переглянути файл
@@ -871,7 +871,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
if !text.is_empty() {
out.push(chunk("agent_message_chunk", text));
}
out.extend(question_update(item));
}
Some("reasoning") => {
let text = reasoning_text(item);
@@ -891,36 +890,6 @@ pub(super) fn history(thread: &Value, cwd: Option<&str>) -> Vec<Value> {
out
}
/// Structured async questions accompany a completed message, even when its text streamed already.
pub(super) fn question_update(item: &Value) -> Option<Value> {
let id = item.get("id")?.as_str().filter(|id| !id.is_empty())?;
let questions: Vec<Value> = item
.get("questions")?
.as_array()?
.iter()
.enumerate()
.filter_map(|(index, q)| {
let title = q.get("title")?.as_str().filter(|title| !title.trim().is_empty())?;
let options: Vec<Value> = q
.get("options")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
.filter(|label| !label.trim().is_empty())
.map(|label| json!({ "label": label, "description": "" }))
.collect();
Some(json!({ "answerKey": json!(["request_user_input_async", id, index]).to_string(),
"question": title, "header": "", "multiSelect": false, "options": options }))
})
.collect();
if questions.is_empty() {
return None;
}
Some(json!({ "sessionUpdate": "user_question", "id": id,
"title": questions[0]["question"], "questions": questions }))
}
/// A reasoning item's summary (or, without one, its raw text).
pub(super) fn reasoning_text(item: &Value) -> String {
let parts = |k: &str| -> Vec<String> {
@@ -954,18 +923,8 @@ fn str_of(v: &Value, key: &str) -> Option<String> {
/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
pub(super) fn mcp_config(params: &Value) -> Option<Value> {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(std::path::PathBuf::from);
let cwd = params.get("cwd").and_then(Value::as_str).map_or_else(|| std::path::Path::new("."), std::path::Path::new);
let external = crate::mcp::codex_external_server_names(home.as_deref(), cwd);
mcp_config_with_external(params, &external)
}
pub(super) fn mcp_config_with_external(
params: &Value,
external_names: &std::collections::BTreeSet<String>,
) -> Option<Value> {
let mut servers = serde_json::Map::new();
for server in params.get("mcpServers").and_then(Value::as_array).into_iter().flatten() {
for server in params.get("mcpServers")?.as_array()? {
if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
continue;
}
@@ -987,16 +946,5 @@ pub(super) fn mcp_config_with_external(
"args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
);
}
for name in params
.pointer("/_meta/openidea/mcpServersOff")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
if !servers.contains_key(name) && external_names.contains(name) {
servers.insert(name.to_owned(), json!({ "enabled": false }));
}
}
(!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
}
+31 -107
Переглянути файл
@@ -19,7 +19,6 @@ mod translate;
mod tests;
use super::Shim;
use crate::BACKGROUND_TASKS_UPDATE;
use crate::acp::AUTH_REQUIRED;
use crate::provider::ProviderSpec;
use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
@@ -297,25 +296,6 @@ struct SessionEntry {
prompt: Option<oneshot::Sender<TurnTerminal>>,
early_cancel: Option<Instant>,
temp_files: Vec<PathBuf>,
/// Copilot's main agent loop is processing. It goes idle (`assistant.idle`) before the
/// turn ends (`session.idle`) while background shells or agents it started still run.
main_busy: bool,
/// Counts `session.tasks.list` requests, so only the latest answer is reported.
tasks_seq: u64,
}
impl SessionEntry {
fn new(settings: Settings) -> Self {
Self {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
main_busy: false,
tasks_seq: 0,
}
}
}
struct CopilotEvents(Weak<CopilotShim>);
@@ -431,7 +411,6 @@ impl CopilotShim {
"session/set_config_option" => self.set_config(&params).await,
"session/prompt" => self.prompt(&params, false).await,
"_openidea/steer" => self.prompt(&params, true).await,
"_openidea/stop_task" => self.stop_task(&params).await,
"session/close" => self.close_session(&params).await,
_ => Err(error(codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
}
@@ -446,7 +425,7 @@ impl CopilotShim {
"promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
"mcpCapabilities": { "http": true, "sse": true, "stdio": true },
"sessionCapabilities": { "close": {}, "list": {} },
"_meta": { "openidea": { "steer": true, "backgroundTasks": true } },
"_meta": { "openidea": { "steer": true } },
},
"agentInfo": {
"name": "copilot",
@@ -492,9 +471,6 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let created = self.call("session.create", req).await?;
let session_id = created
@@ -513,7 +489,16 @@ impl CopilotShim {
}
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(session_id.clone(), SessionEntry::new(settings));
self.state.lock().sessions.insert(
session_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.publish_commands(&session_id, cwd);
Ok(json!({
"sessionId": session_id,
@@ -542,9 +527,6 @@ impl CopilotShim {
if let Some(mcp) = translate::wire_mcp_servers(params.get("mcpServers")) {
req["mcpServers"] = mcp;
}
if let Some(disabled) = translate::wire_disabled_mcp_servers(params) {
req["disabledMcpServers"] = disabled;
}
let resumed = self.call("session.resume", req).await?;
if let Ok(current) = self.call("session.model.getCurrent", json!({ "sessionId": session_id })).await {
@@ -560,7 +542,16 @@ impl CopilotShim {
}
let actual_id = resumed.get("sessionId").and_then(Value::as_str).unwrap_or(&session_id).to_owned();
let options = models::config_options(&catalog, &settings);
self.state.lock().sessions.insert(actual_id.clone(), SessionEntry::new(settings));
self.state.lock().sessions.insert(
actual_id.clone(),
SessionEntry {
settings,
translator: EventTranslator::default(),
prompt: None,
early_cancel: None,
temp_files: Vec::new(),
},
);
self.publish_commands(&actual_id, cwd);
Ok(json!({
"sessionId": actual_id,
@@ -662,11 +653,7 @@ impl CopilotShim {
let (text, attachments, temp_files) = build_prompt_payload(&session_id, blocks);
if steer {
let (is_running, main_busy) = {
let st = self.state.lock();
let entry = st.sessions.get(&session_id);
(entry.is_some_and(|e| e.prompt.is_some()), entry.is_some_and(|e| e.main_busy))
};
let is_running = self.state.lock().sessions.get(&session_id).is_some_and(|e| e.prompt.is_some());
if !is_running {
cleanup_files(&temp_files);
return Err(error(codes::INVALID_PARAMS, "no turn running to steer"));
@@ -674,25 +661,14 @@ impl CopilotShim {
let mut send_req = json!({
"sessionId": session_id,
"prompt": text,
"mode": "immediate",
});
// Joins the running loop; once it went idle (only background work is left), a plain
// send starts the loop again with this message.
if main_busy {
send_req["mode"] = json!("immediate");
}
if !attachments.is_empty() {
send_req["attachments"] = Value::Array(attachments);
}
if !main_busy && let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
// Stop must abort the run this send starts, even before `assistant.turn_start`.
entry.main_busy = true;
}
let res = self.call("session.send", send_req).await;
if let Some(entry) = self.state.lock().sessions.get_mut(&session_id) {
entry.temp_files.extend(temp_files);
if res.is_err() && !main_busy {
entry.main_busy = false;
}
}
res?;
return Ok(json!({}));
@@ -709,7 +685,6 @@ impl CopilotShim {
let mode = entry.settings.mode.wire();
if !early {
entry.prompt = Some(done_tx);
entry.main_busy = true;
}
(mode, early)
};
@@ -759,24 +734,19 @@ impl CopilotShim {
}
fn cancel(&self, session_id: &str) {
let (has_turn, ended) = {
let has_turn = {
let mut st = self.state.lock();
match st.sessions.get_mut(session_id) {
Some(entry) if entry.prompt.is_none() => {
if let Some(entry) = st.sessions.get_mut(session_id) {
if entry.prompt.is_none() {
entry.early_cancel = Some(Instant::now());
(false, None)
false
} else {
true
}
// The agent is done with the turn and only its background work runs, which
// `session.idle` waits for: the turn ends now and that work keeps running
// (it shows as background tasks, stoppable one by one).
Some(entry) if !entry.main_busy => (false, entry.prompt.take()),
Some(_) => (true, None),
None => (false, None),
} else {
false
}
};
if let Some(tx) = ended {
let _ = tx.send(TurnTerminal::Idle { aborted: true });
}
if has_turn {
let peer = self.copilot().clone();
let sid = session_id.to_owned();
@@ -820,23 +790,10 @@ impl CopilotShim {
return;
}
let main_agent = event.get("agentId").and_then(Value::as_str).is_none_or(str::is_empty);
let event_type = event.get("type").and_then(Value::as_str).unwrap_or_default();
if main_agent && event_type == "session.background_tasks_changed" {
self.refresh_background_tasks(session_id);
}
let catalog_snapshot = self.catalog.try_lock().ok().and_then(|g| g.clone());
let (updates, done) = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
if main_agent {
match event_type {
"assistant.turn_start" => entry.main_busy = true,
"assistant.idle" | "session.idle" | "session.error" => entry.main_busy = false,
_ => {}
}
}
let fallback_limit =
catalog_snapshot.as_deref().and_then(|models| entry.settings.active_context_tokens(models));
let translated = entry.translator.translate(session_id, event, fallback_limit);
@@ -846,44 +803,11 @@ impl CopilotShim {
for (target_session, update) in updates {
self.send_update(&target_session, update);
}
if main_agent && event_type == "session.idle" {
// Nothing runs in the background any more.
self.send_update(session_id, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [] }));
}
if let Some((tx, outcome)) = done {
let _ = tx.send(outcome);
}
}
/// Reports the session's running background shells and agents (`session.tasks.list`).
fn refresh_background_tasks(self: &Arc<Self>, session_id: &str) {
let seq = {
let mut st = self.state.lock();
let Some(entry) = st.sessions.get_mut(session_id) else { return };
entry.tasks_seq += 1;
entry.tasks_seq
};
let shim = self.clone();
let sid = session_id.to_owned();
self.runtime.spawn(async move {
let Ok(list) = shim.call("session.tasks.list", json!({ "sessionId": sid })).await else { return };
let latest = shim.state.lock().sessions.get(&sid).is_some_and(|e| e.tasks_seq == seq);
if latest {
let tasks = translate::background_tasks(&list);
shim.send_update(&sid, json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }));
}
});
}
/// Stops one background shell or agent (`session.tasks.cancel`).
async fn stop_task(self: &Arc<Self>, params: &Value) -> Result<Value, ResponseError> {
let session_id = str_param(params, "sessionId")?;
let task_id = str_param(params, "taskId")?;
self.call("session.tasks.cancel", json!({ "sessionId": session_id, "id": task_id })).await?;
self.refresh_background_tasks(session_id);
Ok(json!({}))
}
fn handle_permission_event(self: &Arc<Self>, session_id: &str, event: &Value) {
let data = &event["data"];
if data.get("resolvedByHook").and_then(Value::as_bool) == Some(true) {
+1 -148
Переглянути файл
@@ -6,7 +6,6 @@ use ide_jsonrpc::{Framing, Handler, Peer, codes};
use parking_lot::Mutex;
use serde_json::{Value, json};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
fn sample_models_list() -> Value {
json!({
@@ -341,12 +340,6 @@ fn headless_and_acp_args_roundtrip_while_preserving_user_flags() {
struct FakeCopilotServer {
peer: OnceLock<Peer>,
calls: Mutex<Vec<(String, Value)>>,
/// `session.send` leaves a shell running: the main loop goes idle but the session doesn't.
background_shell: bool,
}
fn copilot_event(sid: &str, event: Value) -> Value {
json!({ "sessionId": sid, "event": event })
}
impl Handler for FakeCopilotServer {
@@ -362,36 +355,12 @@ impl Handler for FakeCopilotServer {
"commands.list" => Ok(json!({ "commands": [{ "name": "compact", "description": "Compact context" }] })),
"skills.discover" => Ok(json!({ "skills": [] })),
"session.create" => Ok(json!({ "sessionId": "cop-sess-1" })),
"session.resume" => Ok(json!({ "sessionId": params["sessionId"] })),
"session.model.getCurrent" => Ok(json!({ "modelId": "gemini-4-carbon" })),
"session.model.switchTo" => Ok(json!({ "modelId": params["modelId"] })),
"session.mode.set" => Ok(json!({})),
"session.permissions.setApproveAll" => {
assert!(params.get("enabled").and_then(Value::as_bool).is_some());
Ok(json!({ "success": true }))
}
"session.tasks.list" => Ok(json!({ "tasks": [
{ "id": "shell-1", "type": "shell", "status": "running", "description": "",
"command": "gh pr checks 3819 --watch", "attachmentMode": "attached" },
{ "id": "shell-0", "type": "shell", "status": "completed", "description": "ls", "command": "ls" },
] })),
"session.tasks.cancel" => Ok(json!({ "cancelled": true })),
"session.abort" => Ok(json!({})),
"session.send" if self.background_shell => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
std::thread::spawn(move || {
for event in [
json!({ "id": "b1", "type": "assistant.turn_start", "data": { "turnId": "t1" } }),
json!({ "id": "b2", "type": "assistant.idle", "data": {} }),
json!({ "id": "b3", "type": "session.background_tasks_changed", "data": {} }),
] {
let _ = peer.notify("session.event", copilot_event(&sid, event));
}
});
}
Ok(json!({ "messageId": "msg-1" }))
}
"session.send" => {
if let Some(peer) = self.peer.get().cloned() {
let sid = params["sessionId"].as_str().unwrap_or("cop-sess-1").to_owned();
@@ -454,8 +423,7 @@ impl Handler for CollectUpdates {
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_turns() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let server = Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()) });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
@@ -570,118 +538,3 @@ async fn shim_creates_session_with_copilot_defaults_switches_tiers_and_streams_t
.any(|u| u["sessionUpdate"] == "usage_update" && u["size"] == 200_000 && u["used"] == 42_000)
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shim_forwards_disabled_mcp_servers_on_create_and_resume() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: false });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates, move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let _: Value = client.request("initialize", json!({}), None).await.unwrap();
let disabled = json!(["datadog", "github-mcp-server", "linear", "playwright", "slack-official"]);
let _: Value = client
.request(
"session/new",
json!({
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let _: Value = client
.request(
"session/load",
json!({
"sessionId": "cop-sess-1",
"cwd": "/tmp",
"mcpServers": [],
"_meta": { "openidea": { "mcpServersOff": disabled } }
}),
None,
)
.await
.unwrap();
let calls = server.calls.lock();
let (_, create_params) = calls.iter().find(|(m, _)| m == "session.create").unwrap();
assert_eq!(create_params["disabledMcpServers"], disabled);
let (_, resume_params) = calls.iter().find(|(m, _)| m == "session.resume").unwrap();
assert_eq!(resume_params["disabledMcpServers"], disabled);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn stop_ends_a_turn_left_running_only_by_background_shells() {
let server =
Arc::new(FakeCopilotServer { peer: OnceLock::new(), calls: Mutex::new(Vec::new()), background_shell: true });
let updates = Arc::new(CollectUpdates(Mutex::new(Vec::new())));
let server_clone = server.clone();
let client = attach(updates.clone(), move |events| {
let (a, b) = tokio::io::duplex(1 << 16);
let (ar, aw) = tokio::io::split(a);
let (br, bw) = tokio::io::split(b);
let srv_peer = Peer::connect_framed(br, bw, server_clone.clone(), Framing::ContentLength);
let _ = server_clone.peer.set(srv_peer);
Ok(Peer::connect_framed(ar, aw, events, Framing::ContentLength))
})
.unwrap();
let init: Value = client.request("initialize", json!({}), None).await.unwrap();
assert_eq!(init["agentCapabilities"]["_meta"]["openidea"]["backgroundTasks"], true);
let _: Value = client.request("session/new", json!({ "cwd": "/tmp", "mcpServers": [] }), None).await.unwrap();
let prompt_client = client.clone();
let turn = tokio::spawn(async move {
prompt_client
.request::<_, Value>(
"session/prompt",
json!({ "sessionId": "cop-sess-1", "prompt": [{ "type": "text", "text": "watch CI" }] }),
None,
)
.await
});
// The running shell shows as a background task.
let mut shown = None;
for _ in 0..500 {
shown = updates.0.lock().iter().find(|u| u["sessionUpdate"] == crate::BACKGROUND_TASKS_UPDATE).cloned();
if shown.is_some() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(
shown.unwrap()["tasks"],
json!([{ "task_id": "shell-1", "task_type": "local_bash", "description": "gh pr checks 3819 --watch" }])
);
let _: Value = client
.request("_openidea/stop_task", json!({ "sessionId": "cop-sess-1", "taskId": "shell-1" }), None)
.await
.unwrap();
assert!(
server
.calls
.lock()
.iter()
.any(|(m, p)| m == "session.tasks.cancel" && p["sessionId"] == "cop-sess-1" && p["id"] == "shell-1")
);
// The main loop is idle, so Stop ends the turn even though `session.idle` never comes.
assert!(!turn.is_finished());
client.notify("session/cancel", json!({ "sessionId": "cop-sess-1" })).unwrap();
let res = tokio::time::timeout(Duration::from_secs(5), turn).await.unwrap().unwrap().unwrap();
assert_eq!(res["stopReason"], "cancelled");
assert!(!server.calls.lock().iter().any(|(m, _)| m == "session.abort"));
}
-30
Переглянути файл
@@ -522,14 +522,6 @@ pub(super) fn wire_mcp_servers(acp_servers: Option<&Value>) -> Option<Value> {
(!out.is_empty()).then_some(Value::Object(out))
}
/// Extracts `_meta.openidea.mcpServersOff` into Copilot's `disabledMcpServers` string array.
pub(super) fn wire_disabled_mcp_servers(params: &Value) -> Option<Value> {
let list = params.pointer("/_meta/openidea/mcpServersOff")?.as_array()?;
let names: Vec<Value> =
list.iter().filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(|s| json!(s))).collect();
(!names.is_empty()).then_some(Value::Array(names))
}
/// Converts `commands.list` + `skills.discover` results into ACP `availableCommands`.
pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Option<&Value>) -> Vec<Value> {
let mut seen = HashSet::new();
@@ -576,28 +568,6 @@ pub(super) fn available_commands(commands_res: Option<&Value>, skills_res: Optio
out
}
/// The running entries of a `session.tasks.list` result, in the background-task shape the
/// app shows (`task_id`, `task_type`, `description`).
pub(super) fn background_tasks(list: &Value) -> Vec<Value> {
let tasks = list.get("tasks").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();
tasks
.iter()
.filter(|t| matches!(str_of(t, "status"), Some("running" | "idle")))
.filter_map(|t| {
let id = str_of(t, "id")?;
let kind = str_of(t, "type").unwrap_or_default();
let task_type = match kind {
"shell" => "local_bash",
"agent" => "local_agent",
other => other,
};
let description =
str_of(t, "description").filter(|d| !d.is_empty()).or_else(|| str_of(t, "command")).unwrap_or(kind);
Some(json!({ "task_id": id, "task_type": task_type, "description": description }))
})
.collect()
}
fn trim_tail(text: &mut String) {
if text.len() > MAX_OUTPUT {
let mut cut = text.len() - MAX_OUTPUT;
-7
Переглянути файл
@@ -56,13 +56,6 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
&["npx", "-y", "@agentclientprotocol/[email protected]"],
"Run `codex login` in a terminal.",
),
(
"deepseek-harness",
"DeepSeek Harness",
Driver::Acp,
&["dsh", "--profile", "acp"],
"Run `dsh` in a terminal and sign in.",
),
("gemini", "Gemini CLI", Driver::Acp, &["gemini", "--experimental-acp"], "Run `gemini` in a terminal and sign in."),
(
"copilot",
+25 -346
Переглянути файл
@@ -39,8 +39,6 @@ struct FakeAgent {
authenticate_method: Option<String>,
authenticated: AtomicBool,
request_error: Option<(i64, String)>,
/// `session/load` fails with this, as OMP does for a session whose model it can't restore.
load_error: Option<(i64, String)>,
auth_methods: Vec<Value>,
/// Hold the late mode reply until the prompt's permission request is already waiting.
hold_late_mode: bool,
@@ -53,7 +51,6 @@ struct FakeAgent {
/// Config options `session/new` reports after the model one (per-model efforts, say).
extra_options: Mutex<Vec<Value>>,
model_options: Mutex<HashMap<String, Vec<Value>>>,
model_config_gate: Mutex<Option<std::sync::mpsc::Receiver<()>>>,
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
/// instead of `_meta.openidea.steer`.
session_steering: bool,
@@ -214,7 +211,6 @@ impl Handler for FakeAgent {
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
Ok(json!({"outcome": outcome, "queue": "steering"}))
}
"session/load" if self.load_error.is_some() => Err(self.load_error.clone().unwrap()),
"session/load" => {
self.say(&session, "replayed history");
Ok(json!({}))
@@ -235,12 +231,6 @@ impl Handler for FakeAgent {
std::thread::sleep(self.delay_config);
}
self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
if params["configId"] == "model" {
let gate = self.model_config_gate.lock().take();
if let Some(gate) = gate {
gate.recv().unwrap();
}
}
if params["configId"] == "model" && !self.model_options.lock().is_empty() {
return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
}
@@ -248,10 +238,6 @@ impl Handler for FakeAgent {
}
"session/prompt" => {
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
if text.starts_with("<send_user_message_question_reply>") {
self.say(&session, "answer received");
return Ok(json!({"stopReason": "end_turn"}));
}
if text == "again" {
self.say(&session, "second turn");
return Ok(json!({"stopReason": "end_turn"}));
@@ -604,7 +590,6 @@ for line in sys.stdin:
assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);
assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));
let restored = manager(root, Arc::new(FakeAgent::default()));
restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap();
assert_eq!(first, restored.commands("claude", None).await.unwrap());
// The same handshake lists the models, so the composer has them before any task.
for mgr in [&mgr, &restored] {
@@ -873,7 +858,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
["session/load", "authenticate", "authenticate github_oauth", "session/load", "session/prompt"],
);
// If `authenticate` fails during `session/load`, the sign-in error stands: no new session replaces it.
// If `authenticate` fails during `session/load`, fallback to `session/new` does not try it again.
mgr2.shutdown();
let agent3 = Arc::new(FakeAgent {
auth_on_load: true,
@@ -892,7 +877,7 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
.iter()
.filter(|c| c.starts_with("session/") || c.starts_with("authenticate"))
.collect::<Vec<_>>(),
["session/load", "authenticate"],
["session/load", "authenticate", "session/new"],
);
mgr3.shutdown();
}
@@ -1157,127 +1142,10 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
assert!(calls.contains(&"session/set_mode \"code\"".to_owned()), "{calls:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_session_that_fails_to_load_is_reported_and_replaced_only_when_sent_again() {
let tmp = tempfile::tempdir().unwrap();
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let saved = mgr.task(&task.id).unwrap().state.lock().session_id.clone().expect("a session");
mgr.shutdown();
// OMP: "Could not restore model …" for a session saved with a model it can't restore.
let agent = Arc::new(FakeAgent {
load_error: Some((codes::INTERNAL_ERROR, "Could not restore model x".into())),
..Default::default()
});
let mgr = manager(tmp.path(), agent.clone());
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
let calls = |agent: &FakeAgent| -> Vec<String> {
agent.calls.lock().iter().filter(|c| c.starts_with("session/")).cloned().collect()
};
assert_eq!(calls(&agent), ["session/load"], "no new session behind the user's back");
let handle = mgr.task(&task.id).unwrap();
assert_eq!(handle.state.lock().session_id.as_deref(), Some(saved.as_str()));
assert!(mgr.entries(&task.id, None).unwrap().iter().any(|e| matches!(e,
AgentEntry::Error { message } if message.contains("Could not restore model x") && message.contains("Send the message again"))));
// Sending again is the user's choice to continue without the earlier conversation.
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert_eq!(calls(&agent), ["session/load", "session/new", "session/prompt"]);
}
fn text(t: &str) -> AgentPrompt {
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
}
fn asynchronous_question() -> Value {
json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]})
}
#[tokio::test(flavor = "multi_thread")]
async fn async_question_answers_join_the_turn_and_skipping_does_not_cancel_it() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..Default::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("wait"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
let handle = mgr.task(&task.id).unwrap();
handle.on_update(Some("s1"), &asynchronous_question());
assert!(mgr.answer_question(&task.id, "call-1", Some("{}".into())).await.is_err());
handle.live.lock().as_mut().unwrap().capabilities.steer = false;
assert!(mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.is_err());
assert!(handle.state.lock().task.queue.is_empty());
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
handle.live.lock().as_mut().unwrap().capabilities.steer = true;
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
assert!(
agent.calls.lock().iter().any(|call| call.starts_with("_session/steering ") && call.contains("questionItemId"))
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/cancel"));
assert!(mgr.answer_question(&task.id, "call-1", None).await.is_err());
let mut question = asynchronous_question();
question["id"] = json!("call-2");
handle.on_update(Some("s1"), &question);
mgr.answer_question(&task.id, "call-2", None).await.unwrap();
assert!(
matches!(mgr.entries(&task.id, None).unwrap().last(), Some(AgentEntry::Question { chosen: Some(chosen), .. }) if chosen == "Skipped")
);
assert_eq!(handle.state.lock().task.status, AgentStatus::Running);
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn async_questions_can_be_answered_after_the_turn_ends() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.task(&task.id).unwrap().on_update(Some("s1"), &asynchronous_question());
mgr.answer_question(&task.id, "call-1", Some(r#"{"q1":["One"]}"#.into())).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
assert!(
mgr.entries(&task.id, None)
.unwrap()
.iter()
.any(|entry| matches!(entry, AgentEntry::Question { chosen: Some(answer), .. } if answer == "Which?: One"))
);
let entries = mgr.entries(&task.id, None).unwrap();
assert!(
entries.iter().any(|entry| matches!(entry, AgentEntry::User { text, .. } if text.contains("questionItemId")))
);
}
#[tokio::test(flavor = "multi_thread")]
async fn steers_through_session_steering() {
let tmp = tempfile::tempdir().unwrap();
@@ -1338,15 +1206,25 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert_eq!(queue.iter().map(|q| q.prompt.text.as_str()).collect::<Vec<_>>(), ["again"]);
assert!(mgr.prompt(&task.id, text(" "), false).await.is_err());
// Sending it now joins the running turn when the agent takes messages mid-turn.
mgr.send_queued_now(&task.id, &queue[0].id).await.unwrap();
assert!(agent.calls.lock().iter().any(|c| c == "_openidea/steer \"again\""));
assert!(!agent.calls.lock().iter().any(|c| c == "session/cancel"));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "again")));
mgr.cancel(&task.id, None).unwrap();
mgr.send_queued_now(&task.id, &queue[0].id).unwrap();
for _ in 0..500 {
if mgr.entries(&task.id, None).unwrap().iter().any(|e| *e == AgentEntry::Agent { text: "second turn".into() }) {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let users: Vec<String> = mgr
.entries(&task.id, None)
.unwrap()
.into_iter()
.filter_map(|e| match e {
AgentEntry::User { text, .. } => Some(text),
_ => None,
})
.collect();
assert_eq!(users, ["wait", "again"]);
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
// Stopping a turn keeps the queue for later.
mgr.prompt(&task.id, text("wait"), false).await.unwrap();
@@ -1361,40 +1239,6 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
project_root: None,
prompt: text("wait"),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Running).await;
mgr.prompt(&task.id, text("too late"), false).await.unwrap();
let queued = mgr.task(&task.id).unwrap().state.lock().task.queue[0].id.clone();
mgr.send_queued_now(&task.id, &queued).await.unwrap();
// The fake agent's next turn asks for permission.
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
let calls = agent.calls.lock().clone();
assert!(calls.contains(&"_session/steering \"too late\"".to_owned()), "{calls:?}");
assert!(calls.contains(&"session/cancel".to_owned()), "{calls:?}");
let entries = mgr.entries(&task.id, None).unwrap();
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
mgr.cancel(&task.id, None).unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
}
#[tokio::test(flavor = "multi_thread")]
async fn subagents_get_their_own_conversation() {
let tmp = tempfile::tempdir().unwrap();
@@ -1459,25 +1303,6 @@ async fn subagents_get_their_own_conversation() {
check(&manager(tmp.path(), Arc::new(FakeAgent::default())));
}
#[test]
fn image_blocks_declare_the_type_of_their_bytes() {
let image = |mime: &str, data: &str| AgentImage { mime_type: mime.into(), data: data.into(), name: None };
let cases = [
// A browser's JPEG pasted as PNG.
(image("image/png", "/9j/4AAQSkZJRgABAQ"), "image/jpeg"),
(image("image/jpeg", "iVBORw0KGgoAAAANSUhEUg"), "image/png"),
(image("image/png", "R0lGODlhAQABAIAAAP"), "image/gif"),
(image("image/png", "UklGRiQAAABXRUJQVlA4"), "image/webp"),
// Not recognised: as declared.
(image("image/bmp", "Qk02AAAAAAAAADYAAA"), "image/bmp"),
(image("image/png", "AAA"), "image/png"),
];
for (image, expected) in cases {
let p = AgentPrompt { text: String::new(), files: vec![], images: vec![image] };
assert_eq!(blocks(&p, &[])[0]["mimeType"], expected, "{:?}", p.images[0].data);
}
}
#[test]
fn prompts_become_acp_content_blocks() {
let p = AgentPrompt {
@@ -2106,7 +1931,8 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
#[tokio::test(flavor = "multi_thread")]
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
// Idle selections use cached model controls or discover them before the next prompt.
// After a model switch no session reported, picking that model again or changing
// another setting must not record the task's effort-less copy as the model's levels.
for (option, value) in [("mode", "code"), ("model", "big")] {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
@@ -2119,7 +1945,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude-acp".into(),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
@@ -2131,165 +1957,18 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
mgr.shutdown();
let restored = manager(tmp.path(), agent);
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
{
let small = restored.task(&task.id).unwrap();
let small = small.state.lock();
let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap();
assert_eq!(
effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(),
["minimal", "medium"]
);
}
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
restored.set_config(&task.id, option, value.into()).await.unwrap();
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap();
let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap();
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
let saved: HashMap<String, Known> =
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}");
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
restored.shutdown();
}
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.model_options.lock() = HashMap::from([
("big".into(), effort_options(&["low", "high"], "high")),
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
("plain".into(), vec![]),
]);
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), agent.clone());
assert!(
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
);
agent.calls.lock().clear();
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
let current = restored.task(&task.id).unwrap();
let config = current.state.lock().task.config.clone();
let effort = config.iter().find(|option| option.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
restored.set_config(&task.id, "effort", "medium".into()).await.unwrap();
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
assert!(known.thought_levels["plain"].is_empty());
assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big"));
{
let mut calls = agent.calls.lock();
assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load"));
assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2);
calls.clear();
}
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection");
assert!(current.live.lock().is_none(), "discovery never mutates a task's live session");
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), agent.clone());
agent.calls.lock().clear();
assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err());
let current = restored.task(&task.id).unwrap();
assert_eq!(current.state.lock().task.model.as_deref(), Some("big"));
assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort"));
assert!(
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.model_options.lock() = HashMap::from([
("big".into(), effort_options(&["low", "high"], "high")),
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
("plain".into(), vec![]),
]);
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = Arc::new(manager(tmp.path(), agent.clone()));
agent.calls.lock().clear();
let (release, gate) = std::sync::mpsc::channel();
*agent.model_config_gate.lock() = Some(gate);
let first = tokio::spawn({
let restored = restored.clone();
let id = task.id.clone();
async move { restored.set_config(&id, "model", "small".into()).await }
});
tokio::time::timeout(Duration::from_secs(5), async {
while agent.model_config_gate.lock().is_some() {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
let duplicate = restored.set_config(&task.id, "model", "small".into());
tokio::pin!(duplicate);
tokio::select! {
biased;
result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"),
_ = tokio::task::yield_now() => {}
}
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
release.send(()).unwrap();
first.await.unwrap().unwrap();
duplicate.await.unwrap();
let current = restored.task(&task.id).unwrap();
assert_eq!(current.state.lock().task.model.as_deref(), Some("plain"));
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
assert!(catalog.thought_levels["plain"].is_empty());
assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings");
assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2);
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
for (effort, applied) in [("medium", true), ("high", false)] {
-36
Переглянути файл
@@ -54,23 +54,6 @@ impl Timeline {
let mut out = Applied::default();
let kind = update.get("sessionUpdate").and_then(Value::as_str).unwrap_or_default();
match kind {
"user_question" => {
let id = str_field(update, "id");
let Ok(questions) = serde_json::from_value::<Vec<crate::model::AgentQuestion>>(
update.get("questions").cloned().unwrap_or(Value::Null),
) else {
return out;
};
if id.is_empty()
|| questions.is_empty()
|| self.entries.iter().any(|e| matches!(e, AgentEntry::Question { id: known, .. } if known == &id))
{
return out;
}
let index =
self.push(AgentEntry::Question { id, title: str_field(update, "title"), questions, chosen: None });
out.changed.push(index);
}
"agent_message_chunk" | "agent_thought_chunk" => {
let Some(text) = content_text(update.get("content")) else { return out };
out.changed.push(self.append_text(kind == "agent_thought_chunk", &text));
@@ -405,25 +388,6 @@ mod tests {
use super::*;
use serde_json::json;
#[test]
fn asynchronous_questions_survive_turn_end_restart_and_duplicate_notifications() {
let mut t = Timeline::default();
let update = json!({"sessionUpdate":"user_question","id":"call-1","title":"Which?",
"questions":[{"answerKey":"q1","question":"Which?","options":[]}]});
assert_eq!(t.apply(&update).changed, vec![0]);
assert!(t.end_turn(None).is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: None, .. }));
let saved = serde_json::to_string(&t.entries).unwrap();
let mut t = Timeline::from_entries(serde_json::from_str(&saved).unwrap());
assert!(t.apply(&update).changed.is_empty());
assert_eq!(t.entries.len(), 1);
if let AgentEntry::Question { chosen, .. } = &mut t.entries[0] {
*chosen = Some("One".into());
}
assert!(t.apply(&update).changed.is_empty());
assert!(matches!(&t.entries[0], AgentEntry::Question { chosen: Some(answer), .. } if answer == "One"));
}
#[test]
fn chunks_merge_into_one_message_until_another_entry_comes() {
let mut t = Timeline::default();
+6 -22
Переглянути файл
@@ -47,20 +47,13 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def update = {{ t ->
t.dependsOn 'processResources'
// Resolved here so the action holds no task or project (configuration cache).
def dir = p.tasks.getByName('processResources').destinationDir
def manifest = new File({})
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
def resources = p.tasks.named('processResources')
p.tasks.register('openideaUpdateResources') {{
dependsOn resources
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
else p.tasks.create('openideaUpdateResources', update)
}}
"#,
literal(&p.path),
@@ -179,16 +172,7 @@ mod tests {
assert_eq!(gradle.command, "/tools/gradlew");
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
assert!(
script.contains("processResources")
&& script.contains(".destinationDir\n")
&& script.contains("setText(dir.absolutePath")
);
// `register` is Gradle 4.9+ (#3864).
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
}
+3 -3
Переглянути файл
@@ -120,7 +120,7 @@ fn collect(
break;
}
}
let program = process::program_path(&step.program, &step.env, &step.cwd);
let program = process::program_path(&step.program, &step.env);
inputs.push(program.clone());
// Maven installed via a symlink still reads conf from its distribution.
if let Ok(program) = dunce::canonicalize(program)
@@ -131,7 +131,7 @@ fn collect(
}
}
if !environment.contains_key("JAVA_HOME") {
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env, &step.cwd);
let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);
inputs.push(java.clone());
if let Ok(java) = dunce::canonicalize(java)
&& let Some(home) = java.parent().and_then(Path::parent)
@@ -171,7 +171,7 @@ fn collect(
let steps = plan
.steps
.iter()
.map(|s| (process::program_path(&s.program, &s.env, &s.cwd), s.args.clone(), s.cwd.clone(), s.env.clone()))
.map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
.collect();
// Profiles and plugins can read arbitrary environment variables. Keep a signature
// of the inherited environment without persisting unrelated credentials.
+13 -81
Переглянути файл
@@ -10,14 +10,11 @@ use std::process::Command as ProcCommand;
/// Output file of the `dependency:build-classpath` probe, relative to each module.
const CP_FILE: &str = "target/ide-compile-cp.txt";
// Older records include undeclared reactor test outputs even in runtime classpaths.
const CLASSPATH_CACHE_VERSION: u32 = 1;
/// The resolved dependency classpath for one module and scope, tied to the same
/// inputs as its launch build so POM, JDK, settings and profile changes invalidate it.
#[derive(Debug, Deserialize, Serialize)]
struct CachedClasspath {
version: u32,
fingerprint: LaunchFingerprint,
classpath: String,
}
@@ -135,7 +132,6 @@ pub fn module_classpath(
if let (Some(fingerprint), Some(path)) = (&fingerprint, &cache_path)
&& let Ok(bytes) = fs::read(path)
&& let Ok(cached) = serde_json::from_slice::<CachedClasspath>(&bytes)
&& cached.version == CLASSPATH_CACHE_VERSION
&& cached.fingerprint == *fingerprint
&& classpath_entries_exist(root, &cached.classpath)
{
@@ -146,7 +142,7 @@ pub fn module_classpath(
return Err(IdeError::cancelled());
}
if let (Some(fingerprint), Some(path)) = (fingerprint, cache_path) {
let cached = CachedClasspath { version: CLASSPATH_CACHE_VERSION, fingerprint, classpath: classpath.clone() };
let cached = CachedClasspath { fingerprint, classpath: classpath.clone() };
if let Err(error) = cache_classpath(&path, &cached) {
tracing::debug!(path = %path.display(), %error, "Cannot cache the Java launch classpath");
}
@@ -212,11 +208,11 @@ fn classpath(
if dir == target.module {
continue;
}
// A dependency's tests are not exported with its main artifact. Any explicitly
// declared test artifact is supplied by Maven's resolved classpath below.
let path = dir.join("target/classes");
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
for classes in ["target/classes", "target/test-classes"] {
let path = dir.join(classes);
if path.is_dir() {
entries.push(path.to_string_lossy().into_owned());
}
}
}
}
@@ -341,19 +337,13 @@ mod tests {
root,
"pom.xml",
r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
<packaging>pom</packaging><modules><module>shared</module><module>lib</module><module>app</module></modules></project>"#,
<packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
);
write(
root,
"lib/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>lib</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>shared</artifactId><version>1</version></dependency></dependencies></project>"#,
);
write(
root,
"shared/pom.xml",
r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
<artifactId>shared</artifactId></project>"#,
<artifactId>lib</artifactId></project>"#,
);
write(
root,
@@ -364,7 +354,6 @@ mod tests {
write(root, "app/src/main/java/demo/Main.java", "class Main {}");
write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
write(root, "lib/target/classes/Lib.class", "built");
write(root, "shared/target/classes/Shared.class", "built");
crate::load(root, &root.join("cache"), None)
}
@@ -447,9 +436,7 @@ mod tests {
let target = single_file_target(root, &model, &file).unwrap();
assert!(target.top.command.ends_with("mvnw"));
assert_eq!(target.pl, "app");
fs::create_dir_all(root.join("lib/target/test-classes")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
assert!(!std::env::split_paths(&cp).any(|p| p == root.join("lib/target/test-classes")), "{cp}");
let separator = ':';
// Reactor class directories first, so fresh outputs shadow installed snapshots.
let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
@@ -464,16 +451,9 @@ mod tests {
assert!(cp.split(separator).count() >= 3, "{cp}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(!args.lines().any(|a| a == "compile" || a == "package"), "{args}");
fs::create_dir_all(root.join("app/target/test-classes")).unwrap();
let target = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
let cp = single_file_classpath(root, &model, &target).unwrap();
let paths: Vec<_> = std::env::split_paths(&cp).collect();
assert_eq!(paths[0], root.join("app/target/test-classes"));
assert!(paths.contains(&root.join("app/target/classes")), "{cp}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{cp}");
}
/// Launches request Maven's matching scope without adding reactor test outputs.
/// A launch uses runtime dependencies, while tests additionally see test-scope ones.
#[cfg(unix)]
#[test]
fn launch_module_classpath_uses_the_matching_dependency_scope() {
@@ -485,29 +465,15 @@ mod tests {
let script = root.join("mvnw");
fs::write(
&script,
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/fixture-tests.jar:/repo/fixture/target/test-classes' > \"$pl/target/ide-compile-cp.txt\"\n",
"#!/bin/sh\nprintf '%s\\n' \"$@\" > args.txt\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/runtime.jar:/repo/test.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
)
.unwrap();
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
let model = crate::load(root, &root.join("cache"), None);
for dir in
["app/target/classes", "app/target/test-classes", "lib/target/test-classes", "shared/target/test-classes"]
{
fs::create_dir_all(root.join(dir)).unwrap();
}
let cache = root.join("cache");
let runtime =
module_classpath(root, &model, &root.join("app"), false, None, &cache, &CancellationToken::new()).unwrap();
let paths: Vec<_> = std::env::split_paths(&runtime).collect();
assert!(paths.contains(&root.join("app/target/classes")), "{runtime}");
assert!(paths.contains(&root.join("lib/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("app/target/test-classes")), "{runtime}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{runtime}");
assert!(paths.contains(&root.join("shared/target/classes")), "{runtime}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture-tests.jar")), "{runtime}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{runtime}");
assert!(runtime.contains("/repo/runtime.jar"), "{runtime}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "compile"), "{args}");
@@ -516,15 +482,7 @@ mod tests {
let test =
module_classpath(root, &model, &root.join("app"), true, None, &cache, &CancellationToken::new()).unwrap();
assert!(test.contains("/repo/fixture-tests.jar"), "{test}");
let paths: Vec<_> = std::env::split_paths(&test).collect();
assert!(paths.contains(&root.join("app/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("app/target/classes")), "{test}");
assert!(paths.contains(&root.join("lib/target/classes")), "{test}");
assert!(!paths.contains(&root.join("lib/target/test-classes")), "{test}");
assert!(paths.contains(&root.join("shared/target/classes")), "{test}");
assert!(!paths.contains(&root.join("shared/target/test-classes")), "{test}");
assert!(paths.contains(&PathBuf::from("/repo/fixture/target/test-classes")), "{test}");
assert!(test.contains("/repo/test.jar"), "{test}");
let args = fs::read_to_string(root.join("args.txt")).unwrap();
assert!(args.lines().any(|a| a == "-Dmdep.includeScope=test"), "{args}");
}
@@ -533,7 +491,7 @@ mod tests {
/// build input changes; the probe does not run packaging plugins.
#[cfg(unix)]
#[test]
fn launch_classpath_cache_follows_the_runner_jdk_and_format() {
fn launch_classpath_cache_follows_the_runner_jdk() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
@@ -555,7 +513,6 @@ mod tests {
fs::write(home.join("release"), format!("JAVA_VERSION=\"{version}\"\n")).unwrap();
fs::write(home.join("bin/java"), "").unwrap();
}
fs::create_dir_all(root.join("app/target/classes")).unwrap();
let cache = root.join("classpath-cache");
let cancel = CancellationToken::new();
let jdk21 = root.join("jdk21");
@@ -569,30 +526,6 @@ mod tests {
assert_eq!(second, first);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "x");
let record = classpath_cache_path(root, &cache, &root.join("app"), false).unwrap();
let current: serde_json::Value = serde_json::from_slice(&fs::read(&record).unwrap()).unwrap();
let test_output = root.join("lib/target/test-classes");
fs::create_dir_all(&test_output).unwrap();
let polluted = std::env::join_paths(std::env::split_paths(&first).chain([test_output])).unwrap();
let mut calls = "x".to_owned();
for version in [None, Some(0), Some(u32::MAX)] {
let mut stale = current.clone();
stale["classpath"] = polluted.to_string_lossy().as_ref().into();
if let Some(version) = version {
stale["version"] = version.into();
} else {
stale.as_object_mut().unwrap().remove("version");
}
fs::write(&record, serde_json::to_vec(&stale).unwrap()).unwrap();
let rebuilt = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(rebuilt, first, "incompatible cache format {version:?} must be rebuilt");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
let reused = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert_eq!(reused, rebuilt);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
}
let jdk8 = root.join("jdk8");
for project in &mut model.maven.as_mut().unwrap().projects {
project.env.insert("JAVA_HOME".into(), jdk8.to_string_lossy().into_owned());
@@ -600,7 +533,6 @@ mod tests {
let switched = module_classpath(root, &model, &root.join("app"), false, None, &cache, &cancel).unwrap();
assert!(switched.contains("jdk8/classpath/jdk.jar"), "{switched}");
assert!(!switched.contains("jdk21/classpath/jdk.jar"), "{switched}");
calls.push('x');
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), calls);
assert_eq!(fs::read_to_string(root.join("calls.txt")).unwrap(), "xx");
}
}
+3 -7
Переглянути файл
@@ -30,8 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
def sets = p.extensions.findByName('sourceSets')
if (sets != null) {
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
// and sets whose folders the `idea` plugin lists as test sources.
@@ -52,12 +51,9 @@ def describe = { Project p ->
}
}
try {
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
def java = p.extensions.findByName('java')
def lv = null
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
def lv = java?.toolchain?.languageVersion?.getOrNull()
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
} catch (ignored) {}
println '@openidea-model\t' + JsonOutput.toJson(m)
}
+1 -83
Переглянути файл
@@ -1,16 +1,13 @@
//! A Gradle project's resolved dependencies for the Dependency Analyzer:
//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
//! The reports it read are kept per build ([`save_gradle_report`]) until a build file
//! changes, for readers that must not run Gradle themselves (plugins).
use crate::gradle;
use crate::process;
use crate::sync::{self, SyncOptions, error_summary};
use crate::sync::{SyncOptions, error_summary};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
/// One line of the report: an occurrence of a dependency where it is requested.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -161,54 +158,6 @@ pub fn gradle_dependencies(
Ok(parse_report(&out.text))
}
/// A `dependencies` report of one project of a build for one configuration.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GradleReport {
/// Gradle path of the project (`:`, `:app`).
pub project: String,
pub configuration: String,
pub dependencies: Vec<GradleDependency>,
}
#[derive(Default, Serialize, Deserialize)]
struct ReportCache {
/// The build files the reports were read with ([`sync::hash_gradle_files`]).
hash: String,
reports: Vec<GradleReport>,
}
const REPORT_CACHE: &str = "gradle-dependencies.json";
/// Keeps `report` with the build's other reports (`cache_dir` is the build's cache
/// directory), replacing an earlier one of the same project and configuration. Reports
/// read before a build file changed are dropped.
pub fn save_gradle_report(
root: &Path,
cache_dir: &Path,
model: &gradle::GradleModel,
report: &GradleReport,
) -> IdeResult<()> {
// Reports of several configurations may finish together: one read-modify-write at a time.
static SAVING: Mutex<()> = Mutex::new(());
let _saving = SAVING.lock().unwrap_or_else(|e| e.into_inner());
let hash = sync::hash_gradle_files(&gradle::build_files(root, model));
let mut cache = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE)
.filter(|c| c.hash == hash)
.unwrap_or_else(|| ReportCache { hash, reports: Vec::new() });
cache.reports.retain(|r| (&r.project, &r.configuration) != (&report.project, &report.configuration));
cache.reports.push(report.clone());
sync::write_cache(cache_dir, REPORT_CACHE, &cache)
}
/// The reports kept for the build, unless a build file changed since they were read.
pub fn gradle_reports(root: &Path, cache_dir: &Path, model: &gradle::GradleModel) -> Vec<GradleReport> {
let Some(cache) = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE) else { return Vec::new() };
if cache.hash != sync::hash_gradle_files(&gradle::build_files(root, model)) {
return Vec::new();
}
cache.reports
}
#[cfg(test)]
mod tests {
use super::*;
@@ -285,37 +234,6 @@ runtimeClasspath - Runtime classpath of source set 'main'.
);
}
#[test]
fn reports_are_kept_per_project_and_configuration_until_a_build_file_changes() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let cache = root.join("cache");
std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
std::fs::write(root.join("build.gradle"), "").unwrap();
let model = gradle::load(root).unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
let report = |project: &str, configuration: &str, version: &str| GradleReport {
project: project.into(),
configuration: configuration.into(),
dependencies: vec![dep("org.a", "b", Some(version))],
};
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "1.0")).unwrap();
save_gradle_report(root, &cache, &model, &report(":app", "compileClasspath", "1.0")).unwrap();
// Reading a report again replaces what was read before.
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "2.0")).unwrap();
assert_eq!(
gradle_reports(root, &cache, &model),
[report(":app", "compileClasspath", "1.0"), report(":app", "runtimeClasspath", "2.0")]
);
// A comment changes nothing Gradle reads; a dependency does.
std::fs::write(root.join("build.gradle"), "// notes").unwrap();
assert_eq!(gradle_reports(root, &cache, &model).len(), 2);
std::fs::write(root.join("build.gradle"), "dependencies { implementation 'org.a:b:3.0' }").unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
save_gradle_report(root, &cache, &model, &report(":", "compileClasspath", "3.0")).unwrap();
assert_eq!(gradle_reports(root, &cache, &model), [report(":", "compileClasspath", "3.0")]);
}
#[cfg(unix)]
#[test]
fn runs_the_report_of_the_project_and_configuration() {
+5 -70
Переглянути файл
@@ -19,7 +19,7 @@ pub mod web;
mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
@@ -127,22 +127,10 @@ pub fn gradle_external_roots(
gradle::external_roots(root, dirs.iter().map(String::as_str))
}
/// Directories outside `root`, outermost only, of Maven POMs linked from there and, in a
/// trusted project, of the modules its reactor lists there (`<module>../service-a</module>`):
/// extra content roots, as IDEA imports such modules with content roots of their own.
/// Linked POMs are read as explicit paths; the reactor's POMs are parsed, but not their
/// parents, and nothing walks directories. `cache_dir` holds the profiles chosen at the last sync.
pub fn maven_external_roots(
root: &Path,
cache_dir: &Path,
settings: &ide_core::settings::MavenSettings,
trusted: bool,
) -> Vec<PathBuf> {
let mut dirs = maven::external_pom_dirs(root, &settings.linked_projects);
if trusted {
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
dirs.extend(maven::reactor_external_dirs(root, &profiles, &settings.unlinked_projects));
}
/// Directories of Maven POMs linked from outside `root`, outermost only.
/// Reads just those explicit paths (no POM parse and no directory walk).
pub fn maven_external_roots(root: &Path, linked: &[String]) -> Vec<PathBuf> {
let dirs = maven::external_pom_dirs(root, linked);
let owned: Vec<String> = dirs.iter().map(|dir| dir.to_string_lossy().into_owned()).collect();
gradle::external_roots(root, owned.iter().map(String::as_str))
}
@@ -263,59 +251,6 @@ mod tests {
assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
}
#[test]
fn reactor_modules_outside_the_root_are_content_roots_of_a_trusted_project() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("workspace");
let cache = base.join("cache");
let write = |rel: &str, text: &str| {
let path = base.join(rel).join("pom.xml");
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, format!("<project><artifactId>{rel}</artifactId>{text}</project>")).unwrap();
};
let reactor = |modules: &str| {
format!(
"<packaging>pom</packaging><modules>{modules}</modules>\
<profiles><profile><id>extra</id><modules><module>../service-c</module></modules></profile></profiles>"
)
};
let all = "<module>core</module><module>../service-a</module><module>..</module>";
write("workspace", &reactor(all));
write("workspace/core", "<modules><module>../../service-d</module></modules>");
write("service-a", "<modules><module>impl</module><module>../service-e</module></modules>");
for module in ["service-a/impl", "service-c", "service-d", "service-e", "unrelated"] {
write(module, "");
}
// The folder holding the project is not a module beside it, nor are its other modules.
write("", "<modules><module>workspace</module><module>unrelated</module></modules>");
let mut settings = ide_core::settings::MavenSettings::default();
let roots = |settings: &ide_core::settings::MavenSettings, trusted| {
maven_external_roots(&root, &cache, settings, trusted)
};
let (a, c, d, e) =
(base.join("service-a"), base.join("service-c"), base.join("service-d"), base.join("service-e"));
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
assert!(roots(&settings, false).is_empty(), "Restricted Mode does not widen the index");
settings.active_profiles = "extra".into();
assert_eq!(roots(&settings, true), [a.clone(), c.clone(), d.clone(), e.clone()]);
save_maven_profiles(&cache, &["!extra".into()]).unwrap();
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
settings.unlinked_projects = vec![a.join("pom.xml").to_string_lossy().replace('\\', "/")];
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
settings.unlinked_projects.clear();
write("workspace", &reactor("<module>core</module>"));
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
write("workspace/core", "");
assert!(roots(&settings, true).is_empty());
write("workspace", &reactor(all));
assert_eq!(roots(&settings, true), [a, e]);
}
#[test]
fn settings_profiles_and_checkbox_choices_control_modules_before_sync() {
let tmp = tempfile::tempdir().unwrap();
+2 -86
Переглянути файл
@@ -1235,86 +1235,6 @@ pub fn external_pom_dirs(root: &Path, linked: &[String]) -> Vec<PathBuf> {
out
}
type FileStamp = Option<(Option<std::time::SystemTime>, u64)>;
fn file_stamp(path: &Path) -> FileStamp {
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
}
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
struct ReactorScan {
stamps: Vec<(PathBuf, FileStamp)>,
dirs: Vec<PathBuf>,
}
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
/// (`<module>../service-a</module>`), with their own modules in turn, including those of
/// the active `profiles`. An `unlinked` POM leaves out its modules too. A folder that
/// holds `root` (`<module>..</module>`) is not a module beside the project and is skipped.
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
/// sizes: content roots are read on hot paths (every references search, Find in Files).
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
{
return scan.dirs.clone();
}
let scan = scan_reactor(root, profiles, unlinked);
let dirs = scan.dirs.clone();
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
dirs
}
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
let chosen = Resolver::new(None, profiles);
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
let first = root.join("pom.xml");
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut pending = vec![first];
while let Some(path) = pending.pop() {
if seen.len() >= MAX_PROJECTS {
break;
}
let canonical = dunce::canonicalize(&path).unwrap_or_else(|_| path.clone());
if !seen.insert(canonical.clone()) || unlinked.contains(&project_rel(&canonical_root, &canonical)) {
continue;
}
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
let dir = path.parent().unwrap_or(root).to_path_buf();
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
if !dir_canon.starts_with(&canonical_root) {
if canonical_root.starts_with(&dir_canon) {
continue;
}
scan.dirs.push(dir_canon);
}
let active: Vec<&RawProfile> = chosen.active(&pom.profiles).collect();
let props: HashMap<String, String> =
pom.properties.iter().chain(active.iter().flat_map(|p| &p.properties)).cloned().collect();
for module in pom.modules.iter().chain(active.iter().flat_map(|p| &p.modules)) {
let module = interpolate(module, &props);
if module.contains("${") {
continue;
}
let mut mp = crate::gradle::normalize(&dir.join(module));
if mp.is_dir() || mp.extension().is_none_or(|e| e != "xml") {
mp.push("pom.xml");
}
scan.stamps.push((mp.clone(), file_stamp(&mp)));
if mp.is_file() {
pending.push(mp);
}
}
}
scan
}
/// Whether `root` holds a Maven build or the settings link one inside it.
pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
@@ -2559,12 +2479,8 @@ mod tests {
assert_eq!(normalized[0], dunce::canonicalize(b.join("pom.xml")).unwrap().to_string_lossy().replace('\\', "/"));
assert_eq!(normalized[1], "pom.xml");
assert_eq!(normalized[2], "stub/pom.xml");
let external_roots = |linked: &[String]| {
let settings = ide_core::settings::MavenSettings { linked_projects: linked.to_vec(), ..Default::default() };
crate::maven_external_roots(&a, &base.join("cache"), &settings, true)
};
assert_eq!(external_roots(&normalized), vec![b.clone()]);
assert_eq!(external_roots(&stored), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
let removed = load_with_linked(&a, None, &[], &[]);
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
+4 -5
Переглянути файл
@@ -25,9 +25,8 @@ pub(crate) struct Output {
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
/// search path — the login shell's `PATH` plus version-manager shims — since the
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there. The `PATH`
/// of the project holding `cwd` (its direnv `.envrc`) comes first.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &Path) -> std::path::PathBuf {
/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.
pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {
let path = std::path::Path::new(program);
if !path.is_relative() || path.components().count() > 1 {
return path.to_path_buf();
@@ -36,7 +35,7 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case("PATH"))
.map(|(_, v)| std::ffi::OsString::from(v))
.unwrap_or_else(|| ide_core::tool_path::search_path_in(cwd));
.unwrap_or_else(ide_core::tool_path::search_path);
ide_core::process::find_executable(program, &search).unwrap_or_else(|| path.to_path_buf())
}
@@ -66,7 +65,7 @@ pub(crate) fn run_with_env(
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
let encoding =
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
let program = program_path(program, env, cwd);
let program = program_path(program, env);
let mut command = Command::new(&program);
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
command.stdout(Stdio::piped()).stderr(Stdio::piped());
+3 -3
Переглянути файл
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
Ok(true)
}
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
}
pub(crate) fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
std::fs::create_dir_all(dir)?;
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
let tmp = dir.join(format!("{name}.tmp"));
@@ -156,7 +156,7 @@ fn hash_files(files: &[PathBuf]) -> String {
/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
/// does not make the last sync stale.
pub(crate) fn hash_gradle_files(files: &[PathBuf]) -> String {
fn hash_gradle_files(files: &[PathBuf]) -> String {
hash_contents(files, |f| {
let text = std::fs::read_to_string(f).unwrap_or_default();
let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
+7 -26
Переглянути файл
@@ -172,25 +172,13 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def artifact = {{ t ->
t.dependsOn 'war'
// Resolved here so the action holds no task or project (configuration cache).
def war = p.tasks.getByName('war')
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
def manifest = new File({})
t.doLast {{
def file = archive instanceof File ? archive : archive.get().asFile
manifest.setText(file.absolutePath, 'UTF-8')
}}
def warTask = p.tasks.named('war')
p.tasks.register('openideaTomcatArtifact') {{
dependsOn warTask
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
else p.tasks.create('openideaTomcatArtifact', artifact)
}}
"#,
groovy_literal(path),
@@ -282,7 +270,7 @@ mod tests {
assert_eq!(a.len(), 1);
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
}
@@ -309,14 +297,7 @@ mod tests {
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
assert!(script.contains(&format!("rootProject.project('{}')", module)));
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
assert!(
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
);
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
}
}
}
-36
Переглянути файл
@@ -348,35 +348,6 @@ mod imp {
paths
}
/// `Preferred DropEffect`: a `DWORD` saying whether the files were copied or cut.
/// Explorer writes it with every file list, and paste targets that move files
/// between machines (Remote Desktop's clipboard redirection, #3863) read it.
fn drop_effect_format() -> u32 {
let name: Vec<u16> = "Preferred DropEffect\0".encode_utf16().collect();
unsafe { RegisterClipboardFormatW(name.as_ptr()) }
}
/// `DROPEFFECT_COPY`.
const DROPEFFECT_COPY: u32 = 1;
/// An `HGLOBAL` holding a copy of `bytes`. Null when the allocation failed.
fn global_bytes(bytes: &[u8]) -> Handle {
unsafe {
let memory = GlobalAlloc(GMEM_MOVEABLE, bytes.len());
if memory.is_null() {
return ptr::null_mut();
}
let data = GlobalLock(memory);
if data.is_null() {
GlobalFree(memory);
return ptr::null_mut();
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len());
GlobalUnlock(memory);
memory
}
}
/// An `HGLOBAL` holding `text` as UTF-16 with a terminating NUL, and its
/// byte size. Null when the allocation failed.
fn global_text(text: &str) -> (Handle, usize) {
@@ -459,13 +430,6 @@ mod imp {
if !taken {
GlobalFree(memory);
}
let effect = drop_effect_format();
if effect != 0 {
let effect_memory = global_bytes(&DROPEFFECT_COPY.to_le_bytes());
if !effect_memory.is_null() && SetClipboardData(effect, effect_memory).is_null() {
GlobalFree(effect_memory);
}
}
let (text_memory, _) = global_text(&text);
if !text_memory.is_null() {
// The text alone still pastes somewhere useful.
-18
Переглянути файл
@@ -1,18 +0,0 @@
[package]
name = "ide-command"
description = "Declares OpenIDEA's backend commands once and derives their adapters, trust class and placement"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
proc-macro = true
[dependencies]
heck.workspace = true
proc-macro2.workspace = true
quote.workspace = true
syn.workspace = true
[dev-dependencies]
serde.workspace = true
-92
Переглянути файл
@@ -1,92 +0,0 @@
// Stand-in for the parts of `ide-host` that the code generated by `#[command]`, `domain!` and
// `domains!` names; doctests `include!` it at their crate root.
pub type IdeResult<T> = Result<T, IdeError>;
#[derive(Debug)]
pub struct IdeError(pub String);
impl IdeError {
pub fn unavailable(m: impl Into<String>) -> Self {
Self(m.into())
}
}
pub struct Host;
impl Host {
pub fn plugin_host(&self) -> Option<std::sync::Arc<plugins::PluginHost>> {
None
}
}
pub mod plugins {
pub struct PluginHost;
}
pub mod catalogue {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrustClass {
Always,
OutsideRestricted,
Trusted,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Placement {
Desktop,
ProjectHost,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
Sync,
Async,
Spawn,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
pub bindings: bool,
pub mode: Mode,
}
}
pub mod ops {
pub struct Channel<T>(pub std::marker::PhantomData<T>);
pub type Emit<T> = std::sync::Arc<dyn Fn(T) + Send + Sync>;
}
pub mod rpc {
use crate::catalogue::TrustClass;
use crate::{IdeResult, ops::Channel};
pub struct Call {
pub host: std::sync::Arc<crate::Host>,
pub window: String,
}
impl Call {
pub fn arg<T: Default>(&self, _name: &str) -> IdeResult<T> {
Ok(T::default())
}
pub fn sender<T>(&self, _name: &str) -> IdeResult<Channel<T>> {
Ok(Channel(std::marker::PhantomData))
}
}
#[derive(Default)]
pub struct Dispatcher(pub Vec<(&'static str, TrustClass)>);
impl Dispatcher {
pub fn add<F, Fut, T>(&mut self, name: &'static str, trust: TrustClass, _f: F) -> &mut Self
where
F: Fn(Call) -> Fut + Send + Sync + 'static,
Fut: Future<Output = IdeResult<T>> + Send + 'static,
T: serde::Serialize,
{
self.0.push((name, trust));
self
}
}
}
-884
Переглянути файл
@@ -1,884 +0,0 @@
//! Declares OpenIDEA's backend commands once, on the fn that implements them.
//!
//! A command that runs on the project host is an `ide-host` fn with `#[command]`; its module
//! lists it in `domain!`, and `ide-host` lists its domains in `domains!`. From that `src-tauri`
//! derives the Tauri adapter and its bindings entry, and `ide-host` derives the JSON-RPC handler
//! `openidea-server` answers. A command only the desktop runs keeps its hand-written Tauri fn,
//! with `#[desktop_command]`, and its module lists it in `desktop_domain!`. Every command
//! declares its trust class, and each declaration yields a `COMMAND`
//! (`ide_host::catalogue::Command`): its name, trust class, placement, bindings entry and
//! execution mode.
//!
//! The examples below build against a stand-in for `ide-host` (`src/doctest_host.rs`). Every
//! `compile_fail` example differs from the example before it only by the mistake it names.
use heck::ToLowerCamelCase;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as T2;
use quote::{ToTokens, format_ident, quote};
use syn::ext::IdentExt;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{FnArg, GenericArgument, Ident, ItemFn, Pat, PathArguments, ReturnType, Token, Type};
/// `#[command(trust = …)]` on a project-host command's implementation in `ide-host`.
///
/// The fn's name is the command's name and its `///` lines are the bindings' docs. Parameters
/// of type `&Host` or `&Arc<Host>`, `window: &str` and `plugins: &Arc<PluginHost>` are injected;
/// every other parameter is an argument, owned, whose key is its camelCase name, and
/// `Channel<T>` streams values back. `async fn` gives an async Tauri adapter, `fn` a sync one.
/// A result of type `IdeResult<T>` is returned as is; any other result is a success. A JSON-RPC
/// request that leaves out an argument marked `#[default]` gets the type's default, so servers
/// keep answering clients older than the argument.
///
/// Options:
/// - `trust = always | outside_restricted | trusted` (required): where the command may run;
/// `always` includes Restricted Mode, `outside_restricted` needs no project or a trusted
/// one, `trusted` needs a trusted project.
/// - `desktop_body = async | sync | spawn`: the Tauri adapter calls the hand-written fn of the
/// same name in `src-tauri` instead of this one, which stays the server's implementation.
/// `spawn` runs that sync body off the invoking thread.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::{Host, IdeResult, ops::Channel};
/// use ide_command::command;
///
/// /// Renames a branch.
/// #[command(trust = trusted)]
/// pub async fn vcs_rename_branch(
/// host: &Host,
/// window: &str,
/// from: String,
/// to: String,
/// unset_upstream: bool,
/// ) -> IdeResult<()> {
/// Ok(())
/// }
///
/// #[command(trust = always)]
/// pub fn vcs_watch(window: &str, #[default] depth: u32, on_event: Channel<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_rename_branch, vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
///
/// fn main() {
/// use catalogue::{Mode, Placement, TrustClass};
/// let mut d = rpc::Dispatcher::default();
/// register_domains(&mut d);
/// assert_eq!(d.0, [("vcs_rename_branch", TrustClass::Trusted), ("vcs_watch", TrustClass::Always)]);
/// let watch = vcs::__cmd_vcs_watch::COMMAND;
/// assert_eq!((watch.placement, watch.bindings, watch.mode), (Placement::ProjectHost, true, Mode::Sync));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_unwatch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// Two commands with one name, in different modules:
///
/// ```compile_fail,E0428
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// pub mod search {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(search: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A borrowed argument:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, path: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A stream that isn't a `Channel<T>`:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// use crate::ops::Emit;
///
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str, on_event: Emit<u32>) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_command(opts: Opts, mut f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "desktop_body"])?;
let trust = opts.trust()?;
// `#[default]` is read here and not emitted.
let defaulted: Vec<bool> = f
.sig
.inputs
.iter_mut()
.map(|input| match input {
FnArg::Typed(pt) => {
let before = pt.attrs.len();
pt.attrs.retain(|a| !a.path().is_ident("default"));
pt.attrs.len() != before
}
FnArg::Receiver(_) => false,
})
.collect();
let name = &f.sig.ident;
if !f.sig.generics.params.is_empty() {
return Err(syn::Error::new_spanned(&f.sig.generics, "a command is not generic"));
}
let is_async = f.sig.asyncness.is_some();
let (run, body) = match opts.value("desktop_body") {
None if is_async => (format_ident!("async"), quote!(derived)),
None => (format_ident!("sync"), quote!(derived)),
Some(Some(m)) if ["async", "sync", "spawn"].contains(&m.to_string().as_str()) => (m, quote!(desktop)),
Some(v) => return Err(error(v.as_ref().unwrap_or(name), "`desktop_body = async | sync | spawn`")),
};
let mode = match run.to_string().as_str() {
"async" => quote!(Async),
"spawn" => quote!(Spawn),
_ => quote!(Sync),
};
let mut aliases = Vec::new(); // one type alias per argument, resolved in the fn's own scope
let mut args = Vec::new(); // the arguments, for the Tauri adapter's signature
let mut call = Vec::new(); // every parameter in declared order, for the Tauri adapter's call
let mut rpc_call = Vec::new(); // the same, for the JSON-RPC handler
let mut needs_plugins = false;
for (input, defaulted) in f.sig.inputs.iter().zip(defaulted) {
let FnArg::Typed(pt) = input else {
return Err(error(input, "a command is a free fn"));
};
let Pat::Ident(pi) = &*pt.pat else {
return Err(error(&pt.pat, "command parameters are plain identifiers"));
};
let ident = &pi.ident;
let plain_only = || error(ident, "`#[default]` marks a plain argument");
if defaulted && injected(ident, &pt.ty).is_some() {
return Err(plain_only());
}
match injected(ident, &pt.ty) {
Some(Injected::Host) => {
call.push(quote!((inj host)));
rpc_call.push(quote!(&c.host));
continue;
}
Some(Injected::Window) => {
call.push(quote!((inj window)));
rpc_call.push(quote!(&c.window));
continue;
}
Some(Injected::Plugins) => {
needs_plugins = true;
call.push(quote!((inj plugins)));
rpc_call.push(quote!(&plugins));
continue;
}
None => {}
}
if matches!(&*pt.ty, Type::Reference(_)) {
return Err(error(
&pt.ty,
"command arguments are owned; the injected references are `&Host`, `window: &str` and `plugins: &Arc<PluginHost>`",
));
}
let seg = last_segment(&pt.ty);
if seg.is_some_and(|s| s.ident == "Emit") {
return Err(error(&pt.ty, "a command streams through `Channel<T>`, not `Emit<T>`"));
}
let key = ident.unraw().to_string().to_lower_camel_case();
let alias = format_ident!("A{}", args.len());
if let Some(inner) = seg.filter(|s| s.ident == "Channel").and_then(type_argument) {
if defaulted {
return Err(plain_only());
}
aliases.push(quote!(pub type #alias = #inner;));
args.push(quote!((#ident channel #alias)));
call.push(quote!((arg channel #ident)));
rpc_call.push(quote!(c.sender(#key)?));
} else {
let ty = &pt.ty;
aliases.push(quote!(pub type #alias = #ty;));
args.push(quote!((#ident plain #alias)));
call.push(quote!((arg plain #ident)));
rpc_call.push(if defaulted {
quote!(c.arg::<::core::option::Option<#ty>>(#key)?.unwrap_or_default())
} else {
quote!(c.arg(#key)?)
});
}
}
let ret: Type = match &f.sig.output {
ReturnType::Default => syn::parse_quote!(()),
ReturnType::Type(_, t) => (**t).clone(),
};
let fallible = last_segment(&ret).is_some_and(|s| s.ident == "IdeResult");
// specta exports `fn f()` as `void` and `fn f() -> ()` as `null`: keep which one was written.
let ret_alias = match &f.sig.output {
ReturnType::Default => quote!(),
ReturnType::Type(..) => quote!(Ret),
};
let shape = if fallible { quote!(fallible [#ret_alias]) } else { quote!(infallible [#ret_alias]) };
let await_ = is_async.then(|| quote!(.await));
let invoke = quote!(super::#name(#(#rpc_call),*) #await_);
let invoke = if fallible { invoke } else { quote!(Ok(#invoke)) };
let plugins = needs_plugins.then(|| {
quote! {
let plugins = c.host.plugin_host()
.ok_or_else(|| crate::IdeError::unavailable("the plugin host has shut down"))?;
}
});
let docs: Vec<_> = f.attrs.iter().filter(|a| a.path().is_ident("doc")).collect();
let module = format_ident!("__cmd_{}", name);
let tokens = format_ident!("__catalogue_{}", name);
let name_str = name.unraw().to_string();
Ok(quote! {
#f
// Resolves only if this module's `domain!` lists the command.
const _: () = self::__listed::#name;
#[doc(hidden)]
#[allow(non_snake_case)]
pub mod #module {
#[allow(unused_imports)]
use super::*;
#(#aliases)*
pub type Ret = #ret;
pub const COMMAND: crate::catalogue::Command = crate::catalogue::Command {
name: #name_str,
trust: crate::catalogue::TrustClass::#trust,
placement: crate::catalogue::Placement::ProjectHost,
bindings: true,
mode: crate::catalogue::Mode::#mode,
};
/// The JSON-RPC handler.
pub async fn rpc(c: crate::rpc::Call) -> crate::IdeResult<impl ::serde::Serialize + use<>> {
#plugins
#invoke
}
}
/// The command's signature, handed to `$cb!` for `src-tauri` to derive its Tauri adapter.
#[doc(hidden)]
#[macro_export]
macro_rules! #tokens {
([$($cb:tt)*] { $($ctx:tt)* }) => {
$($cb)*! { { $($ctx)* } {
name: #name,
module: #module,
docs: [ #(#docs)* ],
run: #run,
result: #shape,
body: #body,
args: [ #(#args)* ],
call: [ #(#call)* ],
} }
};
}
})
}
/// `domain!(vcs: vcs_status, vcs_rename_branch, …)`: the commands one `ide-host` module
/// declares with `#[command]`, in any order. It goes once at the end of that module and gives it
/// the server's `register`; `domains!` names the domain.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
/// # fn main() {}
/// ```
///
/// A listed name that isn't a command:
///
/// ```compile_fail,E0433
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch, vcs_unwatch);
/// }
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domain(input: TokenStream) -> TokenStream {
let Domain { name, commands } = syn::parse_macro_input!(input as Domain);
let modules: Vec<_> = commands.iter().map(|c| format_ident!("__cmd_{}", c)).collect();
let tokens: Vec<_> = commands.iter().map(|c| format_ident!("__catalogue_{}", c)).collect();
let list = format_ident!("__domain_{}", name);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
// Resolves only from the `domains!` entry that names this domain.
#[doc(hidden)]
#[allow(non_upper_case_globals)]
pub(crate) const #list: () = ();
/// Adds this module's commands to the server.
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
#( d.add(#modules::COMMAND.name, #modules::COMMAND.trust, #modules::rpc); )*
}
/// `@each`: each command's signature, in list order. `@names`: the list.
#[doc(hidden)]
#[macro_export]
macro_rules! #list {
(@each [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#( #d crate::#tokens!{ [#d (#d cb)*] { #d (#d ctx)* } } )*
};
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
}
.into()
}
/// `domains!(vcs: crate::ops::vcs::commands, …)`, once in `ide-host`: every domain, by the name
/// its `domain!` gives it and the crate path of its module. It gives the server
/// `register_domains`, and hands `src-tauri` the list of domains through `__domains!`.
///
/// ```
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(vcs: crate::vcs);
/// # fn main() {}
/// ```
///
/// A domain under another name than its `domain!` gives it:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// pub mod vcs {
/// #[ide_command::command(trust = always)]
/// pub fn vcs_watch(window: &str) -> bool {
/// true
/// }
///
/// ide_command::domain!(vcs: vcs_watch);
/// }
///
/// ide_command::domains!(git: crate::vcs);
/// # fn main() {}
/// ```
#[proc_macro]
pub fn domains(input: TokenStream) -> TokenStream {
let entries = syn::parse_macro_input!(input with Punctuated::<DomainPath, Token![,]>::parse_terminated);
let mut names = Vec::new();
let mut paths = Vec::new();
let mut from_crate = Vec::new();
for DomainPath { name, path } in entries {
let mut segments = path.segments.iter();
if path.leading_colon.is_some() || segments.next().is_none_or(|s| s.ident != "crate") {
return error(&path, "a domain's path starts with `crate::`").to_compile_error().into();
}
let rest: Vec<_> = segments.map(|s| &s.ident).collect();
from_crate.push(quote!(#(#rest)::*));
names.push(name);
paths.push(path);
}
let lists: Vec<_> = names.iter().map(|n| format_ident!("__domain_{}", n)).collect();
let d = quote!($);
quote! {
#( const _: () = #paths::#lists; )*
/// Adds every domain's commands to the server.
pub(crate) fn register_domains(d: &mut crate::rpc::Dispatcher) {
#( #paths::register(d); )*
}
/// `@names`: each domain as `(name __domain_name { path })`.
#[doc(hidden)]
#[macro_export]
macro_rules! __domains {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #( (#names #lists { #d crate::#from_crate }) )* ] }
};
}
}
.into()
}
/// `#[desktop_command(trust = …)]` on a command only the desktop runs, above its
/// `#[tauri::command]` in `src-tauri`, whose `(async)` it reads. The fn is left as written.
///
/// Options: `trust` as for `#[command]` (required), and `bindings = none` for a command that is
/// registered outside tauri-specta; such a command isn't listed in `desktop_domain!`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
///
/// fn main() {
/// let text = clipboard::clipboard_text::COMMAND;
/// assert_eq!((text.name, text.placement), ("clipboard_text", catalogue::Placement::Desktop));
/// }
/// ```
///
/// A command without a trust class:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
///
/// A command its module doesn't list:
///
/// ```compile_fail,E0425
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_html() -> Option<String> {
/// None
/// }
///
/// ide_command::desktop_domain!(clipboard_text);
/// }
/// # fn main() {}
/// ```
#[proc_macro_attribute]
pub fn desktop_command(attr: TokenStream, item: TokenStream) -> TokenStream {
let opts = syn::parse_macro_input!(attr as Opts);
let f = syn::parse_macro_input!(item as ItemFn);
expand_desktop_command(opts, f).unwrap_or_else(|e| e.to_compile_error()).into()
}
fn expand_desktop_command(opts: Opts, f: ItemFn) -> syn::Result<T2> {
opts.only(&["trust", "bindings"])?;
let trust = opts.trust()?;
let bindings = match opts.value("bindings") {
None => true,
Some(Some(v)) if v == "none" => false,
Some(v) => return Err(error(v.as_ref().unwrap_or(&f.sig.ident), "`bindings = none`")),
};
// `#[tauri::command(async)]` runs a sync fn off the invoking thread.
let spawned = f.attrs.iter().any(|a| {
let path = a.path();
path.segments.len() == 2
&& path.segments[0].ident == "tauri"
&& path.segments[1].ident == "command"
&& a.parse_args::<Ident>().is_ok_and(|i| i == "async")
});
let mode = if f.sig.asyncness.is_some() {
quote!(Async)
} else if spawned {
quote!(Spawn)
} else {
quote!(Sync)
};
let name = &f.sig.ident;
let name_str = name.unraw().to_string();
let listed = bindings.then(|| quote!(const _: () = self::__listed::#name;));
Ok(quote! {
#f
#listed
#[doc(hidden)]
pub mod #name {
pub const COMMAND: ::ide_host::catalogue::Command = ::ide_host::catalogue::Command {
name: #name_str,
trust: ::ide_host::catalogue::TrustClass::#trust,
placement: ::ide_host::catalogue::Placement::Desktop,
bindings: #bindings,
mode: ::ide_host::catalogue::Mode::#mode,
};
}
})
}
/// `desktop_domain!(clipboard_text, clipboard_write_text, …)`: the `#[desktop_command]`s of one
/// `src-tauri` module that are in the bindings, in any order. It goes once at the end of that
/// module and gives it `__desktop_domain!(@names …)`.
#[proc_macro]
pub fn desktop_domain(input: TokenStream) -> TokenStream {
let commands = syn::parse_macro_input!(input with Punctuated::<Ident, Token![,]>::parse_terminated);
let names = commands.iter();
let listed = commands.iter();
let d = quote!($);
quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod __listed {
#( pub(super) const #listed: () = (); )*
}
#[doc(hidden)]
macro_rules! __desktop_domain {
(@names [#d (#d cb:tt)*] { #d (#d ctx:tt)* }) => {
#d (#d cb)*! { { #d (#d ctx)* } [ #(#names)* ] }
};
}
#[allow(unused_imports)]
pub(crate) use __desktop_domain;
}
.into()
}
/// `sorted_catalogue!(bindings: a::x, b::y, …; raw: c::z, …)`, in `src-tauri`: every command,
/// sorted by name, as `(collect_commands![…bindings…], [COMMAND, …every command…])`. Each path
/// names a command fn and the module of the same name that holds its `COMMAND`.
///
/// ```
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear;
/// raw:
/// );
/// assert_eq!(commands, ["clipboard :: clipboard_clear", "clipboard :: clipboard_text"]);
/// assert_eq!(rows.map(|c| c.name), ["clipboard_clear", "clipboard_text"]);
/// }
/// ```
///
/// Two commands with one name:
///
/// ```compile_fail
/// # include!("doctest_host.rs");
/// # extern crate self as ide_host;
/// # extern crate self as tauri_specta;
/// # #[macro_export]
/// # macro_rules! collect_commands { ($($p:path),*) => { [$(stringify!($p)),*] } }
/// pub mod clipboard {
/// #[ide_command::desktop_command(trust = always)]
/// pub async fn clipboard_text() -> Option<String> {
/// None
/// }
///
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_text, clipboard_clear);
/// }
///
/// pub mod editor {
/// #[ide_command::desktop_command(trust = always)]
/// pub fn clipboard_clear() {}
///
/// ide_command::desktop_domain!(clipboard_clear);
/// }
///
/// fn main() {
/// let (commands, rows) = ide_command::sorted_catalogue!(
/// bindings: clipboard::clipboard_text, clipboard::clipboard_clear, editor::clipboard_clear;
/// raw:
/// );
/// }
/// ```
#[proc_macro]
pub fn sorted_catalogue(input: TokenStream) -> TokenStream {
let Catalogue { bindings, raw } = syn::parse_macro_input!(input as Catalogue);
let key = |p: &syn::Path| p.segments.last().map(|s| s.ident.unraw().to_string()).unwrap_or_default();
let mut bindings: Vec<_> = bindings.into_iter().collect();
bindings.sort_by_cached_key(key);
let mut all: Vec<_> = bindings.iter().chain(&raw).collect();
all.sort_by_cached_key(|p| key(p));
for pair in all.windows(2) {
if key(pair[0]) == key(pair[1]) {
let (a, b) = (pair[0], pair[1]);
let message = format!(
"command `{}` is declared twice: `{}` and `{}`",
key(b),
a.to_token_stream(),
b.to_token_stream()
);
return syn::Error::new_spanned(b, message).to_compile_error().into();
}
}
quote! {
(
::tauri_specta::collect_commands![ #(#bindings),* ],
[ #( #all::COMMAND ),* ],
)
}
.into()
}
struct Catalogue {
bindings: Punctuated<syn::Path, Token![,]>,
raw: Punctuated<syn::Path, Token![,]>,
}
impl Parse for Catalogue {
fn parse(input: ParseStream) -> syn::Result<Self> {
let paths = |input: ParseStream, label: &str| -> syn::Result<Punctuated<syn::Path, Token![,]>> {
let ident: Ident = input.parse()?;
if ident != label {
return Err(error(&ident, &format!("expected `{label}:`")));
}
input.parse::<Token![:]>()?;
let mut out = Punctuated::new();
while !input.is_empty() && !input.peek(Token![;]) {
out.push_value(input.parse()?);
if !input.peek(Token![,]) {
break;
}
out.push_punct(input.parse()?);
}
Ok(out)
};
let bindings = paths(input, "bindings")?;
input.parse::<Token![;]>()?;
let raw = paths(input, "raw")?;
let _ = input.parse::<Option<Token![;]>>()?;
Ok(Self { bindings, raw })
}
}
enum Injected {
Host,
Window,
Plugins,
}
/// `&Host` or `&Arc<Host>` under any name, `window: &str`, `plugins: &Arc<PluginHost>`.
fn injected(ident: &Ident, ty: &Type) -> Option<Injected> {
let Type::Reference(r) = ty else { return None };
if r.mutability.is_some() {
return None;
}
let seg = last_segment(&r.elem)?;
let arc_of =
|name: &str| seg.ident == "Arc" && type_argument(seg).and_then(last_segment).is_some_and(|s| s.ident == name);
if seg.ident == "Host" || arc_of("Host") {
Some(Injected::Host)
} else if ident == "window" && seg.ident == "str" {
Some(Injected::Window)
} else if ident == "plugins" && arc_of("PluginHost") {
Some(Injected::Plugins)
} else {
None
}
}
fn last_segment(ty: &Type) -> Option<&syn::PathSegment> {
match ty {
Type::Path(p) if p.qself.is_none() => p.path.segments.last(),
_ => None,
}
}
fn type_argument(seg: &syn::PathSegment) -> Option<&Type> {
match &seg.arguments {
PathArguments::AngleBracketed(a) => a.args.iter().find_map(|g| match g {
GenericArgument::Type(t) => Some(t),
_ => None,
}),
_ => None,
}
}
fn error(span: impl ToTokens, message: &str) -> syn::Error {
syn::Error::new_spanned(span, message)
}
/// `name: a, b, …`
struct Domain {
name: Ident,
commands: Punctuated<Ident, Token![,]>,
}
impl Parse for Domain {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, commands: Punctuated::parse_terminated(input)? })
}
}
/// `name: crate::path`
struct DomainPath {
name: Ident,
path: syn::Path,
}
impl Parse for DomainPath {
fn parse(input: ParseStream) -> syn::Result<Self> {
let name = input.parse()?;
input.parse::<Token![:]>()?;
Ok(Self { name, path: input.parse()? })
}
}
/// An attribute's options: `key = value` and bare `key`.
struct Opts(Vec<(Ident, Option<Ident>)>);
impl Parse for Opts {
fn parse(input: ParseStream) -> syn::Result<Self> {
let mut out = Vec::new();
while !input.is_empty() {
let key: Ident = input.parse()?;
let value = if input.peek(Token![=]) {
input.parse::<Token![=]>()?;
// `async` is a keyword.
Some(Ident::parse_any(input)?)
} else {
None
};
out.push((key, value));
if !input.is_empty() {
input.parse::<Token![,]>()?;
}
}
Ok(Self(out))
}
}
impl Opts {
fn value(&self, key: &str) -> Option<Option<Ident>> {
self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v.clone())
}
fn only(&self, known: &[&str]) -> syn::Result<()> {
match self.0.iter().map(|(k, _)| k).find(|k| !known.iter().any(|n| *k == n)) {
Some(k) => Err(error(k, &format!("unknown option; the options are {}", known.join(", ")))),
None => Ok(()),
}
}
fn trust(&self) -> syn::Result<T2> {
match self.value("trust").flatten().map(|t| t.to_string()).as_deref() {
Some("always") => Ok(quote!(Always)),
Some("outside_restricted") => Ok(quote!(OutsideRestricted)),
Some("trusted") => Ok(quote!(Trusted)),
_ => Err(syn::Error::new(
proc_macro2::Span::call_site(),
"every command declares its trust class: `trust = always | outside_restricted | trusted`",
)),
}
}
}
-3
Переглянути файл
@@ -343,8 +343,6 @@ pub struct InlayHintsSettings {
/// Hints of other kinds (chaining, closing labels…).
pub other: bool,
pub disabled_languages: Vec<String>,
/// Code vision as a whole (usages, author and language-server lenses); the switches below apply while it is on.
pub code_vision: bool,
/// Code vision: usages above declarations.
pub code_vision_usages: bool,
/// Code vision: last author of a declaration (VCS blame) beside its usages.
@@ -375,7 +373,6 @@ impl Default for InlayHintsSettings {
parameters: true,
other: true,
disabled_languages: Vec::new(),
code_vision: true,
code_vision_usages: true,
code_vision_author: true,
code_vision_no_usages: true,
-33
Переглянути файл
@@ -47,12 +47,6 @@ pub enum IdeEvent {
root: crate::IpcPath,
trusted: bool,
},
/// The project's direnv environment (`.envrc`) could not be loaded, or a file it is read
/// from changed and it can be reloaded.
Direnv {
root: crate::IpcPath,
status: DirenvStatus,
},
/// Files or directories changed on disk (after debouncing, ignore rules applied).
FsChanged {
created: Vec<crate::IpcPath>,
@@ -153,19 +147,6 @@ pub enum IdeEvent {
server: ServerId,
kind: LspRefreshKind,
},
/// A language server asked the user to choose an action, e.g. Dart's
/// "Renamed field will be invisible in …" warning during a rename. Answered
/// with `lsp_message_request_answer`; the server cancels if we reply null.
LspMessageRequest {
id: u32,
server: String,
message: String,
actions: Vec<String>,
},
/// The request was answered or timed out; every window drops its dialog.
LspMessageRequestDone {
id: u32,
},
TerminalExited {
terminal: TerminalId,
code: Option<i32>,
@@ -234,20 +215,6 @@ pub enum AskpassKind {
Confirm,
}
/// See [`IdeEvent::Direnv`].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum DirenvStatus {
/// `direnv` is not installed (on the search path).
NotInstalled,
/// direnv refuses the `.envrc` until the user approves it with `direnv allow`.
Blocked,
/// `direnv export` failed or took too long: what it printed last.
Failed { message: String },
/// `.envrc`, `flake.nix` or `flake.lock` (a file name in the project root) changed.
Changed { file: String },
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum ServerStatus {
-1
Переглянути файл
@@ -19,7 +19,6 @@ pub mod output_encoding;
pub mod platform;
pub mod process;
pub mod project_dir;
pub mod project_env;
pub mod project_roots;
pub mod proxy_settings;
pub mod real_path;
+5 -8
Переглянути файл
@@ -167,11 +167,10 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
/// Gradle's own JVM and the compiler's source encoding are untouched.
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects {
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
tasks.withType(JavaExec).configureEach {
defaultCharacterEncoding = 'UTF-8'
}
}
";
@@ -622,12 +621,10 @@ mod tests {
#[test]
fn gradle_script_respects_the_builds_own_file_encoding() {
let s = GRADLE_FILE_ENCODING_SCRIPT;
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
// Gradle before 4.9 has no `configureEach` (#3864).
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
}
#[test]
-96
Переглянути файл
@@ -1,6 +1,3 @@
use serde::{Deserialize, Serialize};
use specta::Type;
/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
#[cfg(windows)]
pub fn windows_build_number() -> Option<u32> {
@@ -19,61 +16,6 @@ pub fn windows_build_number() -> Option<u32> {
None
}
/// A caption button of a frameless window's title bar.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum WindowButton {
Minimize,
Maximize,
Close,
}
/// Which caption buttons the title bar shows on each side, in order from left to right.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WindowButtonLayout {
pub left: Vec<WindowButton>,
pub right: Vec<WindowButton>,
}
impl Default for WindowButtonLayout {
/// Minimise, maximise, close on the right (Windows, and Linux when the desktop says nothing).
fn default() -> Self {
Self { left: Vec::new(), right: vec![WindowButton::Minimize, WindowButton::Maximize, WindowButton::Close] }
}
}
impl WindowButtonLayout {
/// Reads GTK's `gtk-decoration-layout` (also GNOME's `button-layout`): button names separated
/// by commas, the left side before the colon, e.g. `close,maximize,minimize:icon`. Names other
/// than the three caption buttons (`icon`, `menu`, `appmenu`, `spacer`) are skipped, as are
/// repeats. A value without any caption button is unusable for a frameless window: `None`.
pub fn from_gtk_decoration_layout(layout: &str) -> Option<Self> {
let mut seen = Vec::new();
let mut side = |part: Option<&str>| {
let mut buttons = Vec::new();
for name in part.unwrap_or_default().split(',') {
let button = match name.trim() {
"minimize" => WindowButton::Minimize,
"maximize" => WindowButton::Maximize,
"close" => WindowButton::Close,
_ => continue,
};
if !seen.contains(&button) {
seen.push(button);
buttons.push(button);
}
}
buttons
};
// GTK splits at the first colon only; without one, every button is on the left.
let mut parts = layout.splitn(2, ':');
let left = side(parts.next());
let right = side(parts.next());
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
}
}
#[cfg(test)]
mod tests {
#[test]
@@ -84,42 +26,4 @@ mod tests {
#[cfg(not(windows))]
assert_eq!(build, None);
}
use super::{WindowButton::*, WindowButtonLayout};
fn layout(left: &[super::WindowButton], right: &[super::WindowButton]) -> Option<WindowButtonLayout> {
Some(WindowButtonLayout { left: left.to_vec(), right: right.to_vec() })
}
#[test]
fn reads_gtk_decoration_layouts() {
let cases = [
// KDE Plasma with `ButtonsOnLeft=XAIS` (#3794).
("close,maximize,minimize:icon", layout(&[Close, Maximize, Minimize], &[])),
("close,minimize,maximize:", layout(&[Close, Minimize, Maximize], &[])),
(":minimize,maximize,close", layout(&[], &[Minimize, Maximize, Close])),
// GNOME's default.
("appmenu:close", layout(&[], &[Close])),
("menu:minimize,close", layout(&[], &[Minimize, Close])),
("icon,close:minimize,maximize", layout(&[Close], &[Minimize, Maximize])),
(" close , spacer : minimize ", layout(&[Close], &[Minimize])),
// No colon: GTK puts everything on the left.
("close,minimize", layout(&[Close, Minimize], &[])),
// Only the first colon separates the sides; a button appears once.
("close:minimize:maximize", layout(&[Close], &[])),
("close,close:close,minimize", layout(&[Close], &[Minimize])),
("", None),
(":", None),
("appmenu:", None),
("garbage", None),
];
for (value, expected) in cases {
assert_eq!(WindowButtonLayout::from_gtk_decoration_layout(value), expected, "{value:?}");
}
}
#[test]
fn default_layout_is_on_the_right() {
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
}
}
+12 -95
Переглянути файл
@@ -1,7 +1,6 @@
//! Child-process helpers shared by every crate that spawns tools.
use std::ffi::{OsStr, OsString};
use std::path::Path;
#[cfg(windows)]
use std::process::Stdio;
use std::process::{Child, Command};
@@ -19,8 +18,7 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
/// console child flashes a `cmd` window.
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
///
/// Variables the call site has already set are kept; call it before `env_clear` and after
/// `current_dir`, which picks the project environment.
/// Variables the call site has already set are kept; call it before `env_clear`.
pub fn prepare(cmd: &mut Command) -> &mut Command {
#[cfg(windows)]
{
@@ -518,13 +516,10 @@ mod windows_job {
/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
/// `MAVEN_OPTS`). A child whose `current_dir` is inside a project also gets the project's
/// environment ([`crate::project_env`]), so set it first. Variables the call site has
/// already set are kept.
/// `MAVEN_OPTS`). Variables the call site has already set are kept.
pub fn host_env(cmd: &mut Command) -> &mut Command {
let dir = cmd.get_current_dir().map(Path::to_path_buf);
let fixes = child_env_changes(dir.as_deref());
let shell: Vec<_> = shell_env_for(dir.as_deref()).collect();
let fixes = child_env_changes();
let shell: Vec<_> = shell_env().collect();
if fixes.is_empty() && shell.is_empty() {
return cmd;
}
@@ -545,40 +540,22 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
/// that are not a `std::process::Command` (a PTY `CommandBuilder`). Apply before the call
/// site's own variables. Empty outside an AppImage without an overlay.
pub fn host_env_fixes() -> Vec<(OsString, Option<OsString>)> {
child_env_changes(None)
}
/// [`host_env_fixes`] for a child started in `dir`, the environment of the project holding it included.
pub fn host_env_fixes_in(dir: &Path) -> Vec<(OsString, Option<OsString>)> {
child_env_changes(Some(dir))
child_env_changes()
}
/// This process's environment as a child should inherit it (see [`host_env`]), for call
/// sites that build a child's environment from the IDE's own instead of inheriting it.
pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(None)).into_iter()
}
/// [`host_vars`] for a child started in `dir`.
pub fn host_vars_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
apply_changes(std::env::vars_os().collect(), &child_env_changes(Some(dir))).into_iter()
apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
}
/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
/// included when this process lacks the variable.
pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(None, key.as_ref())
}
/// [`host_var_os`] for a child started in `dir`.
pub fn host_var_os_in(dir: &Path, key: impl AsRef<OsStr>) -> Option<OsString> {
host_var_os_for(Some(dir), key.as_ref())
}
fn host_var_os_for(dir: Option<&Path>, key: &OsStr) -> Option<OsString> {
match child_env_changes(dir).into_iter().find(|(k, _)| k == key) {
let key = key.as_ref();
match child_env_changes().into_iter().find(|(k, _)| k == key) {
Some((_, fixed)) => fixed,
None => std::env::var_os(key).or_else(|| shell_env_for(dir).find(|(k, _)| k == key).map(|(_, v)| v)),
None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
}
}
@@ -601,9 +578,8 @@ fn apply_changes(
vars
}
/// The AppImage fixes, the overlay, the manual proxy's, then those of the project holding
/// `dir` (a later one wins); one entry per name.
fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
/// The AppImage fixes, the overlay, then the manual proxy's (a later one wins); one entry per name.
fn child_env_changes() -> Vec<(OsString, Option<OsString>)> {
let mut changes = appimage_fixes();
let overlay = env_overlay();
changes.retain(|(k, _)| !overlay.iter().any(|(o, _)| o == k));
@@ -612,11 +588,6 @@ fn child_env_changes(dir: Option<&Path>) -> Vec<(OsString, Option<OsString>)> {
let proxy = crate::proxy_settings::proxy().child_env();
changes.retain(|(k, _)| !proxy.iter().any(|(p, _)| p == k));
changes.extend(proxy);
if let Some(dir) = dir {
let project = crate::project_env::for_dir(dir);
changes.retain(|(k, _)| !project.iter().any(|(p, _)| p == k));
changes.extend(project.iter().cloned());
}
changes
}
@@ -696,26 +667,11 @@ pub fn login_env() -> Option<Vars> {
/// Apply before a call site's own variables so those win. Empty until the shell has been read.
/// Names the overlay sets are left out: [`host_env`] gives them their value.
pub fn shell_env() -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(None)
}
/// [`shell_env`] for a child started in `dir`: names the environment of the project holding
/// it sets are left out too.
pub fn shell_env_in(dir: &Path) -> impl Iterator<Item = (OsString, OsString)> {
shell_env_for(Some(dir))
}
fn shell_env_for(dir: Option<&Path>) -> impl Iterator<Item = (OsString, OsString)> {
let overlay = env_overlay();
let project = dir.map(crate::project_env::for_dir).unwrap_or_default();
let vars = login_env().unwrap_or_default();
let lacking: Vec<_> = vars
.iter()
.filter(|(k, _)| {
std::env::var_os(k).is_none()
&& !overlay.iter().any(|(o, _)| o == k)
&& !project.iter().any(|(p, _)| p == k)
})
.filter(|(k, _)| std::env::var_os(k).is_none() && !overlay.iter().any(|(o, _)| o == k))
.cloned()
.collect();
lacking.into_iter()
@@ -1059,45 +1015,6 @@ mod tests {
set_env_overlay(Vec::new());
}
#[test]
fn a_child_inside_a_project_gets_its_environment() {
let root = std::path::Path::new("/openidea-test-process/project");
crate::project_env::set(
root,
vec![
("OPENIDEA_PROJECT_VAR".into(), Some("devshell".into())),
("PATH".into(), Some("/nix/store/x-devshell/bin".into())),
("OPENIDEA_PROJECT_UNSET".into(), None),
],
);
let get = |cmd: &Command, k: &str| cmd.get_envs().find(|(n, _)| *n == k).map(|(_, v)| v.map(OsStr::to_owned));
let mut inside = Command::new("true");
inside.current_dir(root.join("src")).env("OPENIDEA_PROJECT_VAR", "call site");
host_env(&mut inside);
assert_eq!(get(&inside, "PATH"), Some(Some("/nix/store/x-devshell/bin".into())));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_UNSET"), Some(None));
assert_eq!(get(&inside, "OPENIDEA_PROJECT_VAR"), Some(Some("call site".into())), "the call site's value wins");
let mut outside = Command::new("true");
outside.current_dir("/openidea-test-process/other");
host_env(&mut outside);
assert_eq!(get(&outside, "OPENIDEA_PROJECT_VAR"), None);
let mut no_dir = Command::new("true");
host_env(&mut no_dir);
assert_eq!(get(&no_dir, "OPENIDEA_PROJECT_VAR"), None);
// Spawners that build the environment themselves (PTYs, runs) and `PATH` lookups.
assert!(host_env_fixes_in(root).iter().any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v.is_some()));
assert!(host_vars_in(root).any(|(k, v)| k == "OPENIDEA_PROJECT_VAR" && v == "devshell"));
assert_eq!(host_var_os_in(root, "OPENIDEA_PROJECT_VAR"), Some("devshell".into()));
assert_eq!(host_var_os("OPENIDEA_PROJECT_VAR"), None);
let search = crate::tool_path::search_path_in(root);
assert_eq!(std::env::split_paths(&search).next(), Some("/nix/store/x-devshell/bin".into()));
crate::project_env::remove(root);
assert!(host_vars_in(root).all(|(k, _)| k != "OPENIDEA_PROJECT_VAR"));
}
#[test]
fn changes_apply_in_order() {
let vars = apply_changes(
-138
Переглянути файл
@@ -1,138 +0,0 @@
//! Environments of project folders (a project's direnv `.envrc`), for the children started
//! inside them. One process can hold several projects (desktop windows), so unlike the
//! process-wide overlay ([`crate::process::set_env_overlay`]) these are kept per root and
//! found from a child's working directory: see [`crate::process::host_env`] and the `_in`
//! variants next to it.
use crate::CancellationToken;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::time::Duration;
pub type Changes = Arc<Vec<(OsString, Option<OsString>)>>;
struct Entry {
root: PathBuf,
changes: Changes,
loading: bool,
}
static ENTRIES: Mutex<Vec<Entry>> = Mutex::new(Vec::new());
static SETTLED: Condvar = Condvar::new();
fn entries() -> MutexGuard<'static, Vec<Entry>> {
ENTRIES.lock().unwrap_or_else(|e| e.into_inner())
}
/// `root`'s environment is being read: [`wait`] blocks until [`set`] or [`remove`]. Children
/// started meanwhile keep getting the last one read.
pub fn begin_loading(root: &Path) {
let mut entries = entries();
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => entry.loading = true,
None => entries.push(Entry { root: root.to_path_buf(), changes: Changes::default(), loading: true }),
}
}
/// What children started in `root` (or below it) get on top of the IDE's own environment
/// (`None`: removed). Ends a [`begin_loading`].
pub fn set(root: &Path, changes: Vec<(OsString, Option<OsString>)>) {
let mut entries = entries();
let changes = Arc::new(changes);
match entries.iter_mut().find(|e| e.root == root) {
Some(entry) => {
entry.changes = changes;
entry.loading = false;
}
None => entries.push(Entry { root: root.to_path_buf(), changes, loading: false }),
}
SETTLED.notify_all();
}
/// Ends a [`begin_loading`] that read nothing new (an error): the last environment stays.
pub fn settle(root: &Path) {
if let Some(entry) = entries().iter_mut().find(|e| e.root == root) {
entry.loading = false;
}
SETTLED.notify_all();
}
/// `root` has no environment of its own any more (closed, or not trusted).
pub fn remove(root: &Path) {
entries().retain(|e| e.root != root);
SETTLED.notify_all();
}
/// The innermost root holding `dir`.
fn find<'a>(entries: &'a [Entry], dir: &Path) -> Option<&'a Entry> {
entries.iter().filter(|e| dir.starts_with(&e.root)).max_by_key(|e| e.root.components().count())
}
/// The environment of the project holding `dir` (empty outside every project, or before it was read).
pub fn for_dir(dir: &Path) -> Changes {
find(&entries(), dir).map(|e| e.changes.clone()).unwrap_or_default()
}
/// Whether the environment of the project holding `dir` is being read.
pub fn is_loading(dir: &Path) -> bool {
find(&entries(), dir).is_some_and(|e| e.loading)
}
/// Blocks while the environment of the project holding `dir` is being read, or until `cancel`.
/// For what must not start without it: language servers.
pub fn wait(dir: &Path, cancel: &CancellationToken) {
let mut entries = entries();
while !cancel.is_cancelled() && find(&entries, dir).is_some_and(|e| e.loading) {
entries = SETTLED.wait_timeout(entries, Duration::from_millis(200)).unwrap_or_else(|e| e.into_inner()).0;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn the_innermost_project_holding_a_folder_applies() {
let outer = Path::new("/openidea-test-env/outer");
let inner = Path::new("/openidea-test-env/outer/inner");
set(outer, vec![change("A", Some("outer"))]);
set(inner, vec![change("A", Some("inner")), change("B", None)]);
assert_eq!(*for_dir(&outer.join("src")), [change("A", Some("outer"))]);
assert_eq!(*for_dir(&inner.join("src/deep")), [change("A", Some("inner")), change("B", None)]);
assert!(for_dir(Path::new("/openidea-test-env/outer-sibling")).is_empty(), "whole components only");
remove(inner);
assert_eq!(*for_dir(inner), [change("A", Some("outer"))]);
remove(outer);
assert!(for_dir(inner).is_empty());
}
#[test]
fn waiting_ends_once_the_environment_is_read() {
let root = Path::new("/openidea-test-env/waiting");
set(root, vec![change("OLD", Some("1"))]);
begin_loading(root);
assert!(is_loading(&root.join("src")));
assert_eq!(*for_dir(root), [change("OLD", Some("1"))], "the last one read stays until then");
let reader = std::thread::spawn(|| {
std::thread::sleep(Duration::from_millis(100));
set(Path::new("/openidea-test-env/waiting"), vec![change("NEW", Some("2"))]);
});
wait(&root.join("src"), &CancellationToken::new());
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
reader.join().unwrap();
begin_loading(root);
let cancel = CancellationToken::new();
cancel.cancel();
wait(root, &cancel);
settle(root);
assert!(!is_loading(root));
assert_eq!(*for_dir(root), [change("NEW", Some("2"))]);
remove(root);
}
}
+1 -124
Переглянути файл
@@ -653,10 +653,6 @@ pub struct NotificationSettings {
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Terminal command completions (#3712): `off` | `longRunning` | `all`.
pub terminal_completion: String,
/// `longRunning`: the run time a finished command must reach, in seconds.
pub terminal_threshold_seconds: u32,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
@@ -665,24 +661,9 @@ fn default_true() -> bool {
true
}
fn default_terminal_completion() -> String {
"longRunning".to_owned()
}
fn default_terminal_threshold_seconds() -> u32 {
10
}
impl Default for NotificationSettings {
fn default() -> Self {
Self {
balloons: true,
sound: false,
system_notifications: true,
terminal_completion: default_terminal_completion(),
terminal_threshold_seconds: default_terminal_threshold_seconds(),
groups: BTreeMap::new(),
}
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
@@ -760,9 +741,6 @@ pub struct AppearanceSettings {
pub main_menu_style: String,
/// A lone Alt press focuses or opens the main menu (IDEA `ide.windows.main.menu.focus.on.alt`).
pub main_menu_alt: bool,
/// Settings open in a native window of their own (IDEA parity); off opens them
/// as a dialog inside the project window, which needs no new webview.
pub settings_in_separate_window: bool,
/// `subpixel` | `greyscale` | `none`
pub ide_antialiasing: String,
pub editor_antialiasing: String,
@@ -783,35 +761,6 @@ pub struct AppearanceSettings {
pub main_toolbar: Option<MainToolbarSettings>,
/// Appearance › Background Image: an image shown through the IDE window.
pub background_image: BackgroundImageSettings,
/// Appearance › Presentation Assistant: the name and shortcut of each action run.
pub presentation_assistant: PresentationAssistantSettings,
}
/// Appearance › Presentation Assistant: shows the name and shortcut of each action the user runs.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct PresentationAssistantSettings {
pub enabled: bool,
/// `small` | `medium` | `large`.
pub size: String,
/// How long each popup stays, in seconds.
pub duration_seconds: u32,
/// `top-left`, `top`, `top-right`, `bottom-left`, `bottom` or `bottom-right` of the window.
pub position: String,
/// Also show the shortcut of the other platform's keymap (macOS ⇄ Windows/Linux).
pub alternate_keymap: bool,
}
impl Default for PresentationAssistantSettings {
fn default() -> Self {
Self {
enabled: false,
size: "medium".into(),
duration_seconds: 4,
position: "bottom".into(),
alternate_keymap: false,
}
}
}
/// Appearance › Background Image. An empty `path` shows no image.
@@ -891,7 +840,6 @@ impl Default for AppearanceSettings {
menu_icons: true,
main_menu_style: "hamburger".into(),
main_menu_alt: true,
settings_in_separate_window: true,
ide_antialiasing: "greyscale".into(),
editor_antialiasing: "greyscale".into(),
show_tool_window_bars: true,
@@ -904,7 +852,6 @@ impl Default for AppearanceSettings {
status_bar_widgets: BTreeMap::new(),
main_toolbar: None,
background_image: BackgroundImageSettings::default(),
presentation_assistant: PresentationAssistantSettings::default(),
}
}
}
@@ -945,13 +892,7 @@ pub struct EditorSettings {
pub docstring_format: String,
/// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
pub rainbow_brackets: bool,
/// The bracket kinds rainbow brackets colour.
pub rainbow_bracket_kinds: RainbowBracketKinds,
/// Colours the rainbow bracket depth cycles through (2–5).
pub rainbow_bracket_colors: u32,
pub ligatures: bool,
/// Editor › Font and Tools › Terminal › Font: the font pickers list only monospaced fonts.
pub only_monospaced_fonts: bool,
/// Fallback font for glyphs the main font lacks; empty = none.
pub fallback_font: String,
/// Typography Settings › Main font weight (CSS 100–900), as IDEA.
@@ -995,10 +936,7 @@ impl Default for EditorSettings {
semantic_highlighting: false,
docstring_format: "rest".into(),
rainbow_brackets: false,
rainbow_bracket_kinds: RainbowBracketKinds::default(),
rainbow_bracket_colors: 3,
ligatures: false,
only_monospaced_fonts: true,
fallback_font: String::new(),
font_weight: 400,
bold_font_weight: 700,
@@ -1021,23 +959,6 @@ impl Default for EditorSettings {
}
}
/// Color Scheme › Language Defaults › Rainbow brackets: which delimiters are coloured.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct RainbowBracketKinds {
pub round: bool,
pub square: bool,
pub curly: bool,
/// Type argument / parameter delimiters and markup tags, where the syntax tree marks them.
pub angle: bool,
}
impl Default for RainbowBracketKinds {
fn default() -> Self {
Self { round: true, square: true, curly: true, angle: false }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileSettings {
@@ -1830,41 +1751,6 @@ mod tests {
}
}
#[test]
fn rainbow_bracket_options_default_and_round_trip() {
let old: Settings = serde_json::from_str(r#"{"editor":{"rainbowBrackets":true}}"#).unwrap();
assert!(old.editor.rainbow_brackets);
assert_eq!(old.editor.rainbow_bracket_kinds, RainbowBracketKinds::default());
assert_eq!(old.editor.rainbow_bracket_colors, 3);
let defaults = Settings::default().editor;
assert!(!defaults.rainbow_brackets);
let kinds = defaults.rainbow_bracket_kinds;
assert!(kinds.round && kinds.square && kinds.curly && !kinds.angle);
let mut settings = Settings::default();
settings.editor.rainbow_bracket_kinds =
RainbowBracketKinds { round: false, square: true, curly: true, angle: true };
settings.editor.rainbow_bracket_colors = 5;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["rainbowBracketKinds"]["angle"], true);
assert_eq!(json["editor"]["rainbowBracketColors"], 5);
let restored: Settings = serde_json::from_value(json).unwrap();
assert_eq!(restored.editor.rainbow_bracket_kinds, settings.editor.rainbow_bracket_kinds);
assert_eq!(restored.editor.rainbow_bracket_colors, 5);
}
#[test]
fn only_monospaced_fonts_defaults_on_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"ligatures":true}}"#).unwrap();
assert!(old.editor.only_monospaced_fonts);
let mut settings = Settings::default();
settings.editor.only_monospaced_fonts = false;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["onlyMonospacedFonts"], false);
let restored: Settings = serde_json::from_value(json).unwrap();
assert!(!restored.editor.only_monospaced_fonts);
}
#[test]
fn docstring_format_defaults_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
@@ -1963,15 +1849,6 @@ mod tests {
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["mainMenuAlt"], false);
}
#[test]
fn settings_open_in_a_separate_window_unless_turned_off() {
let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
assert!(old.appearance.settings_in_separate_window);
let off: Settings = serde_json::from_str(r#"{"appearance":{"settingsInSeparateWindow":false}}"#).unwrap();
assert!(!off.appearance.settings_in_separate_window);
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["settingsInSeparateWindow"], false);
}
#[test]
fn editor_font_weights_default_to_regular_and_bold() {
let json = serde_json::to_value(Settings::default()).unwrap();
+2 -16
Переглянути файл
@@ -2,7 +2,7 @@
//! their settings come from, installers. An app started from the desktop gets a
//! minimal `PATH`, and version managers set theirs up in shell rc files.
use crate::process::{host_var_os, host_var_os_in, login_env};
use crate::process::{host_var_os, login_env};
use crate::version_managers;
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
@@ -14,16 +14,6 @@ use std::path::{Path, PathBuf};
/// launchers, their settings hooks and tool detection all look here, so a settings
/// hook finds the executable its server is launched from.
pub fn search_path() -> OsString {
search_path_for(None)
}
/// [`search_path`] for a child started in `dir`: the `PATH` of the project holding it
/// ([`crate::project_env`], e.g. a Nix devshell's) comes first.
pub fn search_path_in(dir: &Path) -> OsString {
search_path_for(Some(dir))
}
fn search_path_for(dir: Option<&Path>) -> OsString {
let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from);
let shell_path = login_env().and_then(|env| env.iter().find(|(k, _)| k == "PATH").map(|(_, v)| v.clone()));
let shims: Vec<PathBuf> = version_managers::managers().iter().map(|m| m.shims()).collect();
@@ -31,11 +21,7 @@ fn search_path_for(dir: Option<&Path>) -> OsString {
// entries after the inherited ones so missing user tools still resolve.
let user_path = crate::process::user_path();
let dirs = search_dirs(
match dir {
Some(dir) => host_var_os_in(dir, "PATH"),
None => host_var_os("PATH"),
}
.as_deref(),
host_var_os("PATH").as_deref(),
shell_path.as_deref(),
user_path.as_deref(),
home.as_deref(),
-10
Переглянути файл
@@ -43,9 +43,6 @@ impl Default for VcsSettings {
pub struct GitSettings {
/// Show blame after the current editor line.
pub inline_blame: bool,
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
/// label is plain text and a click on it places the caret as past the line end.
pub inline_blame_clickable: bool,
pub show_branch_in_project_view: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
@@ -57,8 +54,6 @@ pub struct GitSettings {
pub warn_detached_head: bool,
/// Background check for incoming commits: `auto` | `always` | `never`.
pub incoming_check: String,
/// Minutes between background checks for incoming commits.
pub incoming_check_interval: u32,
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
pub protected_branches: String,
/// Initial state of Commit Options › Sign-off Commit.
@@ -83,7 +78,6 @@ impl Default for GitSettings {
fn default() -> Self {
Self {
inline_blame: false,
inline_blame_clickable: true,
show_branch_in_project_view: false,
executable: String::new(),
update_method: "merge".into(),
@@ -91,7 +85,6 @@ impl Default for GitSettings {
warn_crlf: true,
warn_detached_head: true,
incoming_check: "auto".into(),
incoming_check_interval: 15,
protected_branches: "master; main".into(),
sign_off: false,
warn_large_files: true,
@@ -135,8 +128,6 @@ pub struct CommitSettings {
/// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
#[specta(optional)]
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
}
impl Default for CommitSettings {
@@ -158,7 +149,6 @@ impl Default for CommitSettings {
wrap_at_margin: false,
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
}
}
}
+2 -1
Переглянути файл
@@ -214,8 +214,9 @@ pub fn collect(spec: &CoverageReportSpec) -> IdeResult<CoverageSuite> {
CoverageReportSpec::Exported { runner, argv, cwd, env, lcov } => {
let (program, args) =
argv.split_first().ok_or_else(|| IdeError::invalid("empty coverage export command"))?;
let out = ide_core::process::prepare(Command::new(program).current_dir(cwd))
let out = ide_core::process::prepare(&mut Command::new(program))
.args(args)
.current_dir(cwd)
.envs(env)
.output()
.map_err(|e| IdeError::unavailable(format!("cannot run {program}: {e}")))?;
+6 -14
Переглянути файл
@@ -6,16 +6,11 @@ use ide_run::wrap::{self, program_name};
use std::path::Path;
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects { p ->
p.plugins.withId('java') {
p.apply plugin: 'jacoco'
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
allprojects {
plugins.withId('java') {
apply plugin: 'jacoco'
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
}
}
"#;
@@ -396,10 +391,7 @@ mod tests {
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
let (l, report) = launch(&p);
assert_eq!(l.args[0], "--init-script");
let script = std::fs::read_to_string(&l.args[1]).unwrap();
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
}
+14 -17
Переглянути файл
@@ -281,16 +281,15 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
fn adapter_path(env: &[(String, String)], cwd: &Path) -> Option<std::ffi::OsString> {
fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
(!own).then(|| ide_core::tool_path::search_path_in(cwd))
(!own).then(ide_core::tool_path::search_path)
}
/// Directories searched for adapter binaries: managed tools first, then `PATH` (the project's
/// holding `cwd` first) and the usual install spots.
fn search_dirs(cwd: &Path) -> Vec<PathBuf> {
/// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
fn search_dirs() -> Vec<PathBuf> {
let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path_in(cwd)));
dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
{
@@ -319,7 +318,7 @@ fn is_executable(path: &Path, windows: bool) -> bool {
/// extensionless script next to a shim is never started as a program.
pub fn find_binary(command: &str, cwd: &Path) -> Option<PathBuf> {
let pathext = std::env::var("PATHEXT").ok();
find_binary_in(command, cwd, &search_dirs(cwd), cfg!(windows), pathext.as_deref())
find_binary_in(command, cwd, &search_dirs(), cfg!(windows), pathext.as_deref())
}
fn find_binary_in(
@@ -378,10 +377,10 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
return Ok(()); // Reported as a missing adapter when it is started.
};
let mut probe = Command::new(&python);
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.args(["-c", "import debugpy.adapter"])
.current_dir(&spec.cwd)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
@@ -453,13 +452,13 @@ pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
/// Probe the already resolved and verified executable with its launch environment.
async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
let mut probe = Command::new(binary);
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
if let Some(path) = adapter_path(&spec.env) {
probe.env("PATH", path);
}
probe.current_dir(&spec.cwd);
ide_core::process::prepare(probe.as_std_mut());
let probe = probe
.arg("--version")
.current_dir(&spec.cwd)
.envs(spec.env.iter().cloned())
.stdin(Stdio::null())
.stdout(Stdio::piped())
@@ -691,11 +690,9 @@ async fn spawn_adapter(
) -> IdeResult<AdapterIo> {
let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
let mut cmd = Command::new(binary);
if let Some(path) = adapter_path(&spec.env, &spec.cwd) {
if let Some(path) = adapter_path(&spec.env) {
cmd.env("PATH", path);
}
// The working directory first: it picks the project's environment.
cmd.current_dir(&spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
// Every adapter leads its own process group: the program an adapter launches itself
// (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
@@ -703,6 +700,7 @@ async fn spawn_adapter(
ide_core::process::own_group(cmd.as_std_mut());
cmd.args(args)
.envs(spec.env.iter().map(|(k, v)| (k, v)))
.current_dir(&spec.cwd)
.stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
.stdout(Stdio::piped())
.stderr(Stdio::piped())
@@ -845,11 +843,10 @@ mod tests {
#[test]
fn adapters_run_on_the_tool_search_path() {
let search = ide_core::tool_path::search_path();
let cwd = Path::new("/openidea-test-no-project");
assert_eq!(adapter_path(&[], cwd), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())], cwd), Some(search));
assert_eq!(adapter_path(&[]), Some(search.clone()));
assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
// A launch that sets its own (a selected Go SDK's bin first) keeps it.
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())], cwd), None);
assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
// The search path reaches the usual install spots even when this process's `PATH` doesn't.
#[cfg(unix)]
{
+1 -1
Переглянути файл
@@ -55,10 +55,10 @@ pub async fn build(
) -> IdeResult<PathBuf> {
let cargo = find_binary("cargo", cwd).ok_or_else(|| IdeError::unavailable("`cargo` not found on PATH"))?;
let mut cmd = tokio::process::Command::new(cargo);
cmd.current_dir(cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(args)
.arg("--message-format=json-render-diagnostics")
.current_dir(cwd)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
-5
Переглянути файл
@@ -216,11 +216,6 @@ fn settle<T>(result: Result<T, InspectError>) -> IdeResult<Result<T, JvmInspectU
InspectError::TimedOut => U::TimedOut,
InspectError::Closed => U::BackendClosed,
InspectError::Failed(message) => return Err(IdeError::internal(format!("JVM inspector: {message}"))),
// Only the stream trace commands answer these, never the memory view's.
other @ (InspectError::NoSession
| InspectError::NotAtChainStart(_)
| InspectError::Busy
| InspectError::NoTrace) => return Err(IdeError::internal(format!("JVM inspector: {other}"))),
}))
}
+1 -1
Переглянути файл
@@ -23,7 +23,7 @@ use std::time::Duration;
pub use heap::*;
pub use inspect::{JvmFieldsResult, JvmInspectUnavailable, JvmInstancesResult, JvmObjectRef, JvmReferrersResult};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, watch_link};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, watch_link};
#[cfg(all(test, unix))]
pub(crate) use scan::watch_for_attached_jvm;
pub(crate) use scan::{JvmFinder, attach_target, find_attached_jvm, find_local_jvm, local_jdwp_port};
-46
Переглянути файл
@@ -19,7 +19,6 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
mod stream_trace;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
@@ -40,7 +39,6 @@ use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;
use std::sync::{Arc, Weak};
use std::time::Duration;
pub use stream_trace::{TracePhase, TraceProgress, TraceRun, TraceUnavailable};
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -148,9 +146,6 @@ pub struct DebugCapabilities {
pub js_page: bool,
/// The adapter evaluates expressions while the program runs, without a stack frame.
pub live_evaluate: bool,
/// A stream chain can be traced while the program runs it ([`DebugManager::stream_trace`]).
/// Can change during the session, like `jvm_instances`.
pub stream_trace: bool,
}
/// Result of [`DebugManager::redefine_classes`].
@@ -607,7 +602,6 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
jvm_heap: false,
js_page: false,
live_evaluate: false,
stream_trace: false,
}
}
@@ -619,7 +613,6 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities {
caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str());
caps.js_page = js_debug::is_page(session);
caps.live_evaluate = session.adapter == js_debug::ADAPTER;
caps.stream_trace = stream_trace::available(session);
caps
}
@@ -1624,7 +1617,6 @@ impl DebugManager {
// DAP: a response without the flag continued every thread.
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
session.suspended.resumed(ticket, thread_id, all);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
Ok(())
}
@@ -1673,7 +1665,6 @@ impl DebugManager {
step_settled(&session, sent)?;
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1785,7 +1776,6 @@ impl DebugManager {
.await;
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1883,42 +1873,6 @@ impl DebugManager {
jvm_memory::referrers(&*self.session(s)?, object, limit).await
}
/// Gives the session the backend for [`Self::stream_trace`] (used by java-debug sessions
/// only); the UI is told to reload the session's capabilities.
pub fn set_stream_tracer(
&self,
s: DebugSessionId,
tracer: Arc<dyn ide_jvm_inspect::StreamTracer>,
) -> IdeResult<()> {
let session = self.session(s)?;
if session.ended.is_cancelled() {
return Err(no_session(s));
}
stream_trace::set_tracer(&session, tracer);
Ok(())
}
/// Traces the stream chain `plan` (the JSON of `ide_streams::RealRunPlan`) while the program
/// runs it, from `thread_id` stopped where the chain starts. Leaves the thread stopped right
/// after the chain's terminal operation. `cancel` stops keeping records; the program runs on.
pub async fn stream_trace(
&self,
s: DebugSessionId,
thread_id: i64,
plan: Value,
cancel: ide_core::CancellationToken,
progress: impl Fn(TraceProgress) + Send + Sync,
) -> IdeResult<TraceRun> {
let session = self.session(s)?;
Ok(stream_trace::run(self, &session, thread_id, &plan, &cancel, &progress).await)
}
/// Ends the running terminal operation by interrupting its thread, then by throwing into it.
/// `None` when no trace runs.
pub async fn stream_trace_abort(&self, s: DebugSessionId) -> IdeResult<Option<ide_jvm_inspect::AbortState>> {
stream_trace::abort(&*self.session(s)?).await
}
/// HotSwap: reloads the classes compiled since the session started (or since the
/// last reload) into the debuggee (java-debug `redefineClasses`).
pub async fn redefine_classes(&self, s: DebugSessionId) -> IdeResult<HotSwapResult> {
+8 -24
Переглянути файл
@@ -114,10 +114,6 @@ pub(crate) struct Session {
pub jvm_located: watch::Sender<bool>,
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
/// The last trace that finished, until the stop its records were read in ends.
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
pub(crate) quirks: kotlin_lsp::Quirks,
pub(crate) unity_startup_activity: Mutex<Instant>,
@@ -199,13 +195,6 @@ impl Suspension {
self.0.lock().ticket
}
/// The ticket of a stop of `thread` (its own or every thread's) taken after ticket `after`.
pub fn stopped_since(&self, thread: i64, after: u64) -> Option<u64> {
let stops = self.0.lock();
let own = stops.threads.iter().find(|&&(id, _)| id == thread).map(|&(_, ticket)| ticket);
own.max(stops.all).filter(|&ticket| ticket > after)
}
/// After a successful resume-like request for `thread`; `all`: every thread ran.
pub fn resumed(&self, ticket: u64, thread: i64, all: bool) {
self.0.lock().release(Some(thread), all, ticket);
@@ -281,9 +270,6 @@ impl Session {
jvm_located: watch::channel(false).0,
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
stream_tracer: parking_lot::Mutex::new(None),
stream_trace: parking_lot::Mutex::new(None),
stream_trace_done: parking_lot::Mutex::new(None),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
@@ -755,9 +741,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
if crate::stream_trace::resume_traced_stop(s, int("threadId"), all) {
return;
}
s.suspended.stopped(int("threadId"), all);
let mut reason = str_("reason").unwrap_or_else(|| "pause".into());
if let Some(quirks) = s.kotlin_lsp_quirks() {
@@ -777,7 +760,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
// DAP: an event without the flag continues its thread alone. The UI keeps treating
// it as all threads; the suspension, which holds only threads that stopped, need not.
s.suspended.continued(int("threadId"), all.unwrap_or(false));
crate::stream_trace::release_done(s);
s.emit(DebugEvent::Continued {
thread_id: int("threadId").unwrap_or(0),
all_threads_continued: all.unwrap_or(true),
@@ -979,18 +961,20 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
let mut cmd = CommandBuilder::new(program);
// CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
let cwd = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()).map_or(s.spec.cwd.as_path(), Path::new);
for (k, v) in ide_core::process::host_env_fixes_in(cwd) {
for (k, v) in ide_core::process::host_env_fixes() {
match v {
Some(v) => cmd.env(k, v),
None => cmd.env_remove(k),
}
}
for (k, v) in ide_core::process::shell_env_in(cwd) {
for (k, v) in ide_core::process::shell_env() {
cmd.env(k, v);
}
cmd.env("TERM", "xterm-256color");
cmd.cwd(cwd);
match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
Some(cwd) => cmd.cwd(cwd),
None => cmd.cwd(&s.spec.cwd),
}
if let Some(env) = args.get("env").and_then(Value::as_object) {
for (k, v) in env {
match v.as_str() {
@@ -1161,7 +1145,6 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
let classpath =
std::env::join_paths(strings("classPaths")).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
let mut cmd = tokio::process::Command::new(java);
cmd.current_dir(&s.spec.cwd);
ide_core::process::prepare(cmd.as_std_mut());
cmd.args(kotlin_jvm_args(strings("vmArguments"), cfg!(windows)))
// Let the JVM pick its own port (`:0`) and report it below: pre-picking a free
@@ -1180,7 +1163,8 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
.ok_or_else(|| ide_core::IdeError::invalid("Missing Kotlin main class"))?,
)
.args(strings("programArgs"))
.envs(ide_core::process::shell_env_in(&s.spec.cwd))
.current_dir(&s.spec.cwd)
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
-433
Переглянути файл
@@ -1,433 +0,0 @@
//! A stream chain traced while the program itself runs it. The JDT LS bundle arms the trace with
//! the thread stopped where the chain starts; the program runs on `continue`, and the bundle holds
//! the thread inside the terminal operation once it has run, until a `stepOut` brings java-debug
//! to a stop of its own in which the records are read.
use crate::jvm_memory::vm_target;
use crate::session::Session;
use crate::{DebugManager, StepKind};
use ide_core::event::DebugEvent;
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_jvm_inspect::{
AbortState, InspectError, InspectFuture, StreamTracer, TraceCollected, TraceId, TraceState, VmTarget,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
/// Records the bundle keeps; later ones are only counted.
const BUDGET: u32 = 50_000;
const WAIT_MS: u32 = 500;
const STOP_POLL: Duration = Duration::from_millis(20);
const STOP_WAIT: Duration = Duration::from_secs(30);
const RESUME_TIMEOUT: Duration = Duration::from_secs(30);
/// The bundle reaches the JVM through java-debug's own session.
const ADAPTER: &str = "java-debug";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceProgress {
pub phase: TracePhase,
pub records: u64,
pub dropped: u64,
/// Since the program started running the chain, as the bundle measures it.
pub elapsed_ms: u64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum TracePhase {
Arming,
Running,
/// The terminal operation runs on, keeping no more records.
RecordingStopped,
Aborting,
/// The terminal operation finished: stepping out of it and reading the records.
Collecting,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TraceRun {
/// `generation`: the stop the records were read in, the only one their objects are valid in.
Done {
collected: TraceCollected,
generation: u64,
/// Stops of the traced thread while the program ran the chain, resumed unseen.
resumed_stops: u32,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Stop Recording or Abort Operation came before the terminal operation ran.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TraceUnavailable {
/// Not a java-debug session, or no JDT LS bundle behind it.
NoBackend,
NotSuspended,
NotAtChainStart {
detail: String,
},
/// A trace already runs in this session or its JVM.
Busy,
/// java-debug has no debug session for the JVM.
NoSession,
Unsupported {
detail: String,
},
}
/// A trace that finished. Its records keep their objects from being collected until the stop they
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
pub(crate) struct DoneTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: TraceId,
}
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
pub(crate) fn release_done(s: &Session) {
let Some(done) = s.stream_trace_done.lock().take() else { return };
let ended = s.ended.clone();
let session = s.id.0;
tokio::spawn(async move {
tokio::select! {
biased;
() = ended.cancelled() => {}
result = done.tracer.release(&done.target, done.id) => {
if let Err(e) = result {
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
}
}
}
});
}
/// The session's running trace; `id` is `None` until `arm` answers.
pub(crate) struct ActiveTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: Option<TraceId>,
aborting: bool,
thread_id: i64,
/// From the `continue` that runs the chain until the bundle holds the thread after it.
running: bool,
resumed_stops: u32,
}
/// A stop of the traced thread while the program runs the chain is resumed instead of shown, as
/// IntelliJ does (spec G5): the UI keeps Resume locked meanwhile, and a breakpoint java-debug set
/// since the bundle last switched them off, hit inside the terminal's invoke, would hold that
/// invoke forever. java-debug stops a breakpoint's thread alone; a stop of every thread is shown.
/// `true` when the stop was taken.
pub(crate) fn resume_traced_stop(s: &Arc<Session>, thread_id: Option<i64>, all: bool) -> bool {
let Some(thread_id) = thread_id.filter(|_| !all) else { return false };
{
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut().filter(|a| a.running && a.thread_id == thread_id) else { return false };
active.resumed_stops += 1;
}
let s = s.clone();
tokio::spawn(async move {
let sent =
s.conn.request_timeout("continue", serde_json::json!({ "threadId": thread_id }), RESUME_TIMEOUT).await;
if let Err(e) = sent {
tracing::warn!(session = s.id.0, thread_id, "resuming a stop inside a stream trace: {e}");
}
});
true
}
fn set_running(s: &Session, running: bool) {
if let Some(active) = s.stream_trace.lock().as_mut() {
active.running = running;
}
}
/// Frees the session for the next trace however this one ends, a dropped future included.
struct Claim<'s>(&'s Session);
impl Drop for Claim<'_> {
fn drop(&mut self) {
self.0.stream_trace.lock().take();
}
}
pub(crate) fn set_tracer(s: &Session, tracer: Arc<dyn StreamTracer>) {
*s.stream_tracer.lock() = Some(tracer);
s.emit(DebugEvent::Capabilities);
}
fn tracer(s: &Session) -> Option<Arc<dyn StreamTracer>> {
s.stream_tracer.lock().clone().filter(|_| s.adapter == ADAPTER)
}
pub(crate) fn available(s: &Session) -> bool {
tracer(s).is_some()
}
pub(crate) async fn run(
mgr: &DebugManager,
s: &Session,
thread_id: i64,
plan: &Value,
cancel: &CancellationToken,
progress: &(impl Fn(TraceProgress) + Send + Sync),
) -> TraceRun {
let unavailable = |reason| TraceRun::Unavailable { reason };
let Some(tracer) = tracer(s) else { return unavailable(TraceUnavailable::NoBackend) };
let target = vm_target(s);
let _claim = {
let mut slot = s.stream_trace.lock();
if slot.is_some() {
return unavailable(TraceUnavailable::Busy);
}
*slot = Some(ActiveTrace {
tracer: tracer.clone(),
target: target.clone(),
id: None,
aborting: false,
thread_id,
running: false,
resumed_stops: 0,
});
Claim(s)
};
if !s.suspended.get() {
return unavailable(TraceUnavailable::NotSuspended);
}
// The bundle releases the previous trace itself when this one arms.
s.stream_trace_done.lock().take();
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
let token =
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
let mut trace = Trace {
mgr,
s,
tracer: &*tracer,
target: &target,
thread_id,
progress,
token,
arm_sent: false,
id: None,
last: Counts::default(),
};
match trace.drive(plan, cancel).await {
Ok(run) => {
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
}
run
}
Err(run) => {
// A stop from now on is the user's to see.
set_running(s, false);
trace.release().await;
run
}
}
}
/// `None` when no trace runs or it is still arming. The trace itself goes on to report how the
/// abort ended it.
pub(crate) async fn abort(s: &Session) -> IdeResult<Option<AbortState>> {
let (tracer, target, id) = {
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut() else { return Ok(None) };
let Some(id) = active.id else { return Ok(None) };
active.aborting = true;
(active.tracer.clone(), active.target.clone(), id)
};
let result = tokio::select! {
biased;
() = s.ended.cancelled() => return Ok(None),
result = tracer.abort(&target, id) => result,
};
match result {
Ok(state) => Ok(Some(state)),
Err(InspectError::NoTrace) => Ok(None),
Err(e) => Err(IdeError::internal(format!("cannot abort the stream trace: {e}"))),
}
}
#[derive(Default)]
struct Counts {
records: u64,
dropped: u64,
elapsed_ms: u64,
}
struct Trace<'a, P> {
mgr: &'a DebugManager,
s: &'a Session,
tracer: &'a dyn StreamTracer,
/// The stop the trace was armed in.
target: &'a VmTarget,
thread_id: i64,
progress: &'a P,
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
token: String,
arm_sent: bool,
/// Set once `arm` answers.
id: Option<TraceId>,
last: Counts,
}
impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
/// `Err` ends the trace early.
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
let (s, tracer, target) = (self.s, self.tracer, self.target);
self.report(TracePhase::Arming);
self.arm_sent = true;
let id = self
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
.await?
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
self.id = Some(id);
if let Some(active) = s.stream_trace.lock().as_mut() {
active.id = Some(id);
}
// Before the request: the thread can stop again before its reply arrives.
set_running(s, true);
self.dap(self.mgr.resume(s.id, self.thread_id)).await?;
let mut stopped = false;
loop {
if cancel.is_cancelled() && !stopped {
stopped = true;
// Refused when the trace parked or failed just before: `wait` reports that.
match self.until_ended(tracer.stop(target, id)).await? {
Ok(records) => {
self.last.records = records;
self.report(TracePhase::RecordingStopped);
}
Err(e) => tracing::debug!(session = s.id.0, trace = id, "stream trace stop: {e}"),
}
}
match self.inspect(tracer.wait(target, id, WAIT_MS)).await? {
TraceState::Running { records, dropped, elapsed_ms } => {
self.last = Counts { records, dropped, elapsed_ms };
let aborting = s.stream_trace.lock().as_ref().is_some_and(|a| a.aborting);
self.report(if aborting {
TracePhase::Aborting
} else if stopped {
TracePhase::RecordingStopped
} else {
TracePhase::Running
});
}
TraceState::Parked { records, dropped } => {
set_running(s, false);
self.last.records = records;
self.last.dropped = dropped;
break;
}
TraceState::Failed { detail } => return Err(TraceRun::Failed { detail }),
TraceState::Cancelled { detail } => return Err(TraceRun::Cancelled { detail }),
}
}
self.report(TracePhase::Collecting);
let before = s.suspended.ticket();
self.dap(self.mgr.step(s.id, self.thread_id, StepKind::Out)).await?;
// Another thread's stop meanwhile is not this one: the traced thread would still be
// inside the terminal operation.
let stop = async {
loop {
if let Some(ticket) = s.suspended.stopped_since(self.thread_id, before) {
return ticket;
}
tokio::time::sleep(STOP_POLL).await;
}
};
let Ok(generation) = self.until_ended(tokio::time::timeout(STOP_WAIT, stop)).await? else {
// Collecting in the old stop would only be refused as stale.
return Err(TraceRun::Failed { detail: step_out_timeout() });
};
let stopped_in = VmTarget { generation, ..vm_target(s) };
let collected = self.inspect(tracer.collect(&stopped_in, id, self.last.records)).await?;
let resumed_stops = s.stream_trace.lock().as_ref().map_or(0, |a| a.resumed_stops);
Ok(TraceRun::Done { collected, generation, resumed_stops })
}
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
/// undoes either, or does so once a terminal still running returns. Not after a finished
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
/// by its token.
async fn release(&self) {
if self.s.ended.is_cancelled() {
return;
}
let work = match self.id {
Some(id) => self.tracer.release(self.target, id),
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
None => return,
};
if let Ok(Err(e)) = self.until_ended(work).await {
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
}
}
fn report(&self, phase: TracePhase) {
let Counts { records, dropped, elapsed_ms } = self.last;
(self.progress)(TraceProgress { phase, records, dropped, elapsed_ms });
}
/// A reply may never come once the session ends.
async fn until_ended<T>(&self, work: impl Future<Output = T>) -> Result<T, TraceRun> {
tokio::select! {
biased;
() = self.s.ended.cancelled() => Err(ended()),
value = work => Ok(value),
}
}
async fn inspect<T>(&self, work: InspectFuture<'_, T>) -> Result<T, TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.to_string()))
}
async fn dap(&self, work: impl Future<Output = IdeResult<()>>) -> Result<(), TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.message))
}
/// A request that failed because the session was ending says so.
fn failed(&self, detail: String) -> TraceRun {
if self.s.ended.is_cancelled() { ended() } else { TraceRun::Failed { detail } }
}
}
fn step_out_timeout() -> String {
format!(
"java-debug reported no stop within {} s of stepping out of the stream's terminal operation",
STOP_WAIT.as_secs()
)
}
fn ended() -> TraceRun {
TraceRun::Failed { detail: "the debug session ended".into() }
}
fn refused(e: InspectError) -> TraceRun {
use TraceUnavailable as U;
let reason = match e {
InspectError::NotSuspended => U::NotSuspended,
InspectError::Busy => U::Busy,
InspectError::NoSession => U::NoSession,
InspectError::Unsupported(detail) => U::Unsupported { detail },
InspectError::NotAtChainStart(detail) => U::NotAtChainStart { detail },
other => return TraceRun::Failed { detail: other.to_string() },
};
TraceRun::Unavailable { reason }
}
+3 -55
Переглянути файл
@@ -1,7 +1,6 @@
//! Protocol flow against an in-memory fake adapter.
mod jvm_inspect;
mod stream_trace;
use super::*;
use crate::adapter::{AdapterIo, LaunchFuture};
@@ -72,21 +71,10 @@ async fn windows_stop_releases_the_debuggees_port_before_returning() {
.unwrap();
let pid = child.0.id();
child.1 = Some(ide_core::process::ProcessTree::capture(pid));
// A running program: one suspended at a breakpoint is killed at once (#3658), without the
// wait for its tree this test is about.
let h = harness(Script {
debuggee_pid: Some(pid),
supports_terminate,
continued_after_stop: true,
..Default::default()
});
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate, ..Default::default() });
let id = h.start(config()).await.unwrap();
let session = h.manager.session(id).unwrap();
// The pid, then the stop at launch and the `continued` that ends it.
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid)
|| session.suspended.ticket() == 0
|| session.suspended.get()
{
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
let stop = tokio::spawn({
@@ -144,16 +132,6 @@ struct Script {
continue_reply: Option<Value>,
/// Answer `continue` and stop at a breakpoint again, instead of letting the program exit.
stop_after_continue: bool,
/// Answer `stepOut` and stop these threads one after the other, 100 ms apart (java-debug
/// stops the stepping thread right after the call returns).
step_out_stops: &'static [i64],
/// Refuse `stepOut`.
refuse_step_out: bool,
/// Refuse `continue`.
refuse_continue: bool,
/// Stop thread 1 alone at a breakpoint right after each of the first this many `continue`s
/// that `continue_reply` answers.
breakpoints_after_continue: usize,
/// The `reason` of the stop a `next` ends with (`step` when unset; kotlin-lsp says `breakpoint`).
step_reason: Option<&'static str>,
/// Refuse `next`, then stop at a breakpoint (one the program hit meanwhile).
@@ -207,10 +185,6 @@ impl Default for Script {
hang_up_after_stop: false,
continue_reply: None,
stop_after_continue: false,
step_out_stops: &[],
refuse_step_out: false,
refuse_continue: false,
breakpoints_after_continue: 0,
step_reason: None,
refuse_next: false,
invalidated_after_stop: false,
@@ -274,7 +248,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
let mut breakpoints_left = script.breakpoints_after_continue;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -521,21 +494,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
{"label": ""},
]})
),
"continue" if script.refuse_continue => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "continue", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => {
ok!(msg, script.continue_reply.clone().unwrap());
if breakpoints_left > 0 {
breakpoints_left -= 1;
send!(
json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1}})
);
}
}
"stepOut" if script.refuse_step_out => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "stepOut", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
"continue" if script.stop_after_continue => {
ok!(msg, json!({"allThreadsContinued": true}));
send!(
@@ -548,16 +507,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
send!(json!({"type": "event", "event": "terminated"}));
}
"pause" if script.hang_up_on_pause => break,
"stepOut" if !script.step_out_stops.is_empty() => {
ok!(msg, Value::Null);
for (i, thread) in script.step_out_stops.iter().enumerate() {
if i > 0 {
tokio::time::sleep(Duration::from_millis(100)).await;
}
let reason = if i + 1 == script.step_out_stops.len() { "step" } else { "breakpoint" };
send!(json!({"type": "event", "event": "stopped", "body": {"reason": reason, "threadId": thread}}));
}
}
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
"redefineClasses" => {
send!(
@@ -1922,7 +1871,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![],
debugger: Some(ide_language::DebuggerConfig {
-558
Переглянути файл
@@ -1,558 +0,0 @@
//! A stream chain traced while the program runs it, through a session's stream tracer.
use super::*;
use ide_core::CancellationToken;
use ide_jvm_inspect::{
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
TraceState, VmTarget,
};
use std::collections::VecDeque;
use tokio::sync::Notify;
const TRACE: TraceId = 7;
#[derive(Default)]
struct FakeTracer {
/// Answers to `wait`, in order. Once they run out, `wait` signals `waiting` and answers only
/// after more are pushed and `more` is notified.
waits: Mutex<VecDeque<Result<TraceState, InspectError>>>,
arm_error: Mutex<Option<InspectError>>,
stop_error: Mutex<Option<InspectError>>,
collect_error: Mutex<Option<InspectError>>,
/// The record count each `collect` was given.
collect_records: Mutex<Vec<u64>>,
calls: Mutex<Vec<(&'static str, VmTarget)>>,
waiting: Notify,
more: Notify,
}
impl FakeTracer {
fn scripted(waits: impl IntoIterator<Item = TraceState>) -> Arc<Self> {
Self::answering(waits.into_iter().map(Ok))
}
fn answering(waits: impl IntoIterator<Item = Result<TraceState, InspectError>>) -> Arc<Self> {
Arc::new(Self { waits: Mutex::new(waits.into_iter().collect()), ..Self::default() })
}
fn record(&self, name: &'static str, target: &VmTarget) {
self.calls.lock().push((name, target.clone()));
}
fn names(&self) -> Vec<&'static str> {
self.calls.lock().iter().map(|(name, _)| *name).collect()
}
fn target_of(&self, name: &str) -> VmTarget {
self.calls.lock().iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone()).unwrap()
}
}
impl StreamTracer for FakeTracer {
fn arm<'a>(
&'a self,
target: &'a VmTarget,
_thread_id: i64,
_plan: &'a Value,
_budget: u32,
_token: &'a str,
) -> InspectFuture<'a, TraceId> {
self.record("arm", target);
let error = self.arm_error.lock().clone();
Box::pin(async move { error.map_or(Ok(TRACE), Err) })
}
fn wait<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, _ms: u32) -> InspectFuture<'a, TraceState> {
self.record("wait", target);
Box::pin(async move {
loop {
if let Some(state) = self.waits.lock().pop_front() {
return state;
}
self.waiting.notify_one();
self.more.notified().await;
}
})
}
fn stop<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, u64> {
self.record("stop", target);
let error = self.stop_error.lock().clone();
Box::pin(async move { error.map_or(Ok(3), Err) })
}
fn abort<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, AbortState> {
self.record("abort", target);
Box::pin(async { Ok(AbortState::Interrupted) })
}
fn collect<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
self.record("collect", target);
self.collect_records.lock().push(records);
let error = self.collect_error.lock().clone();
Box::pin(async move { error.map_or_else(|| Ok(collected()), Err) })
}
fn release<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, ()> {
self.record("release", target);
Box::pin(async { Ok(()) })
}
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
self.record("releaseArmed", target);
Box::pin(async { Ok(()) })
}
}
fn collected() -> TraceCollected {
TraceCollected {
records: vec![(0, JvmValue::Primitive { type_name: "int".into(), text: "1".into() })],
dropped: 0,
terminal: CollectedTerminal::Void,
skipped_breakpoints: 0,
sequentialized: false,
}
}
fn running(records: u64) -> TraceState {
TraceState::Running { records, dropped: 0, elapsed_ms: 5 }
}
fn parked() -> TraceState {
TraceState::Parked { records: 10, dropped: 0 }
}
/// java-debug keeps the program running after `continue` and stops right after a `stepOut`.
fn java_debug() -> Script {
Script { continue_reply: Some(json!({"allThreadsContinued": true})), step_out_stops: &[1], ..Script::default() }
}
async fn stopped_java(h: &Harness, tracer: &Arc<FakeTracer>) -> DebugSessionId {
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
h.manager.set_stream_tracer(id, tracer.clone()).unwrap();
id
}
async fn trace(h: &Harness, id: DebugSessionId) -> IdeResult<TraceRun> {
let run = h.manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), |_| {});
tokio::time::timeout(Duration::from_secs(10), run).await.expect("the trace did not end")
}
/// A trace in its own task, returned once it waits for the answers its tracer has not got.
async fn hanging_trace(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
hanging_trace_with(h, id, tracer, |_| {}).await
}
async fn hanging_trace_with(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
progress: impl Fn(TraceProgress) + Send + Sync + 'static,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
let manager = h.manager.clone();
let task = tokio::spawn(async move {
manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), progress).await
});
tokio::time::timeout(Duration::from_secs(5), tracer.waiting.notified()).await.expect("the trace did not wait");
task
}
fn phases(seen: &Mutex<Vec<TraceProgress>>) -> Vec<TracePhase> {
seen.lock().iter().map(|p| p.phase).collect()
}
fn progress(phase: TracePhase, records: u64, elapsed_ms: u64) -> TraceProgress {
TraceProgress { phase, records, dropped: 0, elapsed_ms }
}
#[tokio::test]
async fn trace_runs_continue_then_step_out() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { collected: got, generation, resumed_stops } = run else { panic!("not done: {run:?}") };
assert_eq!(got, collected());
assert_eq!(resumed_stops, 0);
assert!(generation > start, "collected in the stop of the trace ({start}), not after it ({generation})");
let commands = h.commands();
let resumed = commands.iter().position(|c| c == "continue").expect("no continue");
let stepped = commands.iter().position(|c| c == "stepOut").expect("no stepOut");
assert!(resumed < stepped, "{commands:?}");
assert_eq!(h.request("continue")["arguments"]["threadId"], 1);
assert_eq!(h.request("stepOut")["arguments"]["threadId"], 1);
assert_eq!(tracer.names(), ["arm", "wait", "wait", "collect"]);
assert_eq!(*tracer.collect_records.lock(), [10], "collect is told how many records the trace parked with");
assert_eq!(tracer.target_of("arm").generation, start);
assert_eq!(tracer.target_of("collect").generation, generation);
assert!(h.manager.session(id).unwrap().suspended.get());
}
#[tokio::test]
async fn trace_reports_progress() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), move |p| sink.lock().push(p)).await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(
*seen.lock(),
[
progress(TracePhase::Arming, 0, 0),
progress(TracePhase::Running, 10, 5),
progress(TracePhase::Collecting, 10, 5),
]
);
}
#[tokio::test]
async fn cancel_stops_recording_once() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), running(12), parked()]);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TracePhase>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p.phase);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "wait", "collect"]);
assert_eq!(
*seen.lock(),
[
TracePhase::Arming,
TracePhase::Running,
TracePhase::RecordingStopped,
TracePhase::RecordingStopped,
TracePhase::Collecting
]
);
}
#[tokio::test]
async fn second_trace_is_busy() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
let second = trace(&h, id).await.unwrap();
assert_eq!(second, TraceRun::Unavailable { reason: TraceUnavailable::Busy });
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 1);
first.abort();
}
#[tokio::test]
async fn trace_ends_when_session_ends() {
// The fake adapter lets the program exit on `continue`.
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let session = h.manager.session(id).unwrap();
let run = trace(&h, id).await.unwrap();
assert_eq!(run, TraceRun::Failed { detail: "the debug session ended".into() });
assert!(session.stream_trace.lock().is_none());
let next = trace(&h, id).await;
assert!(!matches!(next, Ok(TraceRun::Unavailable { reason: TraceUnavailable::Busy })), "{next:?}");
}
#[tokio::test]
async fn dropping_the_trace_frees_the_session() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
first.abort();
assert!(first.await.unwrap_err().is_cancelled());
let session = h.manager.session(id).unwrap();
assert!(session.stream_trace.lock().is_none());
// The first trace resumed the thread.
session.suspended.stopped(Some(1), false);
let again = hanging_trace(&h, id, &tracer).await;
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 2);
again.abort();
}
#[tokio::test]
async fn arm_errors_map_to_unavailable_or_failed() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::NotAtChainStart("the stop is on line 4".into()));
assert_eq!(
trace(&h, id).await.unwrap(),
TraceRun::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "the stop is on line 4".into() } }
);
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert!(!h.commands().iter().any(|c| c == "continue"));
}
#[tokio::test]
async fn abort_reaches_the_running_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), None);
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let task = hanging_trace_with(&h, id, &tracer, move |p| sink.lock().push(p)).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), Some(AbortState::Interrupted));
assert_eq!(tracer.target_of("abort"), tracer.target_of("arm"));
let thrown = "java.lang.RuntimeException: oi-cancel:1";
tracer.waits.lock().extend([Ok(running(4)), Ok(TraceState::Failed { detail: thrown.into() })]);
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
assert_eq!(run, TraceRun::Failed { detail: thrown.into() });
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Aborting]);
assert_eq!(tracer.names().last(), Some(&"release"));
}
#[tokio::test]
async fn failed_wait_passes_its_detail_through() {
let h = harness(java_debug());
let detail = "the program began to exit while the stream ran: stop the debug session";
let tracer = FakeTracer::scripted([running(1), TraceState::Failed { detail: detail.into() }]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: detail.into() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_trace_cancelled_before_its_terminal_says_so() {
let detail = "cancelled before the terminal ran";
let tracer = FakeTracer::scripted([TraceState::Cancelled { detail: detail.into() }]);
let h = harness(java_debug());
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Cancelled { detail: detail.into() });
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_wait_that_errs_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::answering([Ok(running(1)), Err(InspectError::TimedOut)]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert_eq!(tracer.target_of("release"), tracer.target_of("arm"));
}
#[tokio::test]
async fn a_refused_step_out_releases_the_trace() {
let h = harness(Script { refuse_step_out: true, ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { detail } if detail.contains("not suspended")), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn a_refused_continue_releases_the_trace() {
let h = harness(Script { refuse_continue: true, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { .. }), "{run:?}");
assert_eq!(tracer.names(), ["arm", "release"]);
}
#[tokio::test]
async fn a_failed_collect_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
*tracer.collect_error.lock() = Some(InspectError::Stale);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "wait", "collect", "release"]);
}
fn stops(h: &Harness) -> usize {
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Stopped { .. }, .. })).count()
}
#[tokio::test]
async fn a_stop_of_the_traced_thread_while_the_chain_runs_is_resumed_unseen() {
// A breakpoint java-debug set meanwhile, hit inside the terminal's invoke before the bundle
// switched it off: held there, the invoke would never return.
let h = harness(Script { breakpoints_after_continue: 1, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let shown = stops(&h);
let task = hanging_trace(&h, id, &tracer).await;
for _ in 0..200 {
if h.commands().iter().filter(|c| *c == "continue").count() == 2 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(h.commands().iter().filter(|c| *c == "continue").count(), 2, "{:?}", h.commands());
assert_eq!(h.log.lock().iter().rfind(|m| m["command"] == "continue").unwrap()["arguments"]["threadId"], 1);
tracer.waits.lock().push_back(Ok(parked()));
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
let TraceRun::Done { resumed_stops, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(resumed_stops, 1);
assert_eq!(stops(&h), shown + 1, "only the step-out stop is shown, after the trace parked");
}
#[tokio::test]
async fn a_finished_trace_is_not_released() {
// Releasing unpins the records, which the result's values still show until the program runs on.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
}
#[tokio::test]
async fn a_finished_trace_is_released_once_the_program_runs_on() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
h.manager.resume(id, 1).await.unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while !tracer.names().contains(&"release") {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("the finished trace was not released");
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
}
#[tokio::test]
async fn an_arm_without_a_reply_is_released_by_its_token() {
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
}
#[tokio::test]
async fn refused_stop_leaves_the_outcome_to_wait() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
*tracer.stop_error.lock() = Some(InspectError::NoTrace);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "collect"]);
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Running, TracePhase::Collecting]);
}
#[tokio::test]
async fn another_threads_stop_is_not_the_step_out() {
// Thread 2 stops at a breakpoint 100 ms before the traced thread's step out ends.
let h = harness(Script { step_out_stops: &[2, 1], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { generation, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(
generation,
start + 2,
"collected in thread 2's stop, not in the traced thread's step-out stop after it"
);
assert_eq!(tracer.target_of("collect").generation, generation);
}
#[tokio::test]
async fn step_out_without_a_stop_times_out() {
let h = harness(Script { step_out_stops: &[], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
tokio::time::pause();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), |_| {}).await.unwrap();
assert_eq!(
run,
TraceRun::Failed {
detail: "java-debug reported no stop within 30 s of stepping out of the stream's terminal operation".into()
}
);
assert!(h.commands().iter().any(|c| c == "stepOut"));
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn capability_only_for_java_debug() {
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let java = h.start(java_config("launch")).await.unwrap();
assert!(!h.manager.capabilities(java).unwrap().stream_trace);
h.manager.set_stream_tracer(java, tracer.clone()).unwrap();
assert!(h.manager.capabilities(java).unwrap().stream_trace);
let other = h.start(config()).await.unwrap();
h.manager.set_stream_tracer(other, tracer.clone()).unwrap();
assert!(!h.manager.capabilities(other).unwrap().stream_trace);
}
-51
Переглянути файл
@@ -14,7 +14,6 @@ mod snowflake;
pub mod source;
pub mod split;
pub mod sql;
pub mod tools;
mod watch;
pub use watch::SourcesWatch;
@@ -788,56 +787,6 @@ impl DbManager {
Ok(v.unwrap_or_else(|| "Connected".into()))
}
/// Runs `job` with the client tool at `executable` against target `id`, connected like the
/// data source (through its SSH tunnel, with its SSL settings and password), until it exits
/// or `cancel` fires. Connects first, so a missing password fails the way it does for a
/// console. Returns the exit code.
pub async fn run_tool(
&self,
id: &str,
executable: &std::path::Path,
job: &tools::DbToolJob,
cancel: &CancellationToken,
on_output: impl FnMut(Vec<tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let tool = job.tool();
if !tool.is_program(executable) {
return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program())));
}
let source = self.source(id)?;
if source.driver != tool.driver() {
return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name)));
}
self.pool(id).await?;
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, executable, &target, password.as_deref())?;
tools::run(executable, &prepared.args, &prepared.env, prepared.input.as_deref(), cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, executable, &source, None)?;
Ok(tools::command_line(executable, &prepared.args, job.input()))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
pub async fn server_version(&self, id: &str) -> IdeResult<u32> {
let pool = self.pool(id).await?;
if pool.driver() != DbDriver::Postgres {
return Err(IdeError::invalid("not a PostgreSQL data source"));
}
let rows = pool.rows("SHOW server_version_num", 1).await?;
rows.into_iter()
.next()
.and_then(|r| r.into_iter().next().flatten())
.and_then(|v| v.trim().parse().ok())
.ok_or_else(|| IdeError::internal("no server version"))
}
pub fn is_connected(&self, id: &str) -> bool {
self.pools.lock().contains_key(id)
}
-552
Переглянути файл
@@ -1,552 +0,0 @@
//! What a dump or restore dialog asks for, as typed options, and the arguments that do it.
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use ide_core::{IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpFormat {
/// SQL text, restored with `psql`.
Plain,
Custom,
/// A directory of files; the only format `pg_dump` writes in parallel.
Directory,
Tar,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpStatements {
Copy,
Inserts,
ColumnInserts,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpContent {
All,
SchemaOnly,
DataOnly,
}
/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names).
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgDumpOptions {
pub format: DbDumpFormat,
pub statements: DbDumpStatements,
pub content: DbDumpContent,
pub schemas: Vec<String>,
pub tables: Vec<String>,
pub exclude_tables: Vec<String>,
/// Plain format only: archives get DROP / CREATE at restore.
pub clean: bool,
pub if_exists: bool,
pub create: bool,
pub no_owner: bool,
pub no_privileges: bool,
/// Directory format only.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
/// Creates the database the archive names; the target is only connected to.
pub create: bool,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
pub no_privileges: bool,
pub single_transaction: bool,
pub exit_on_error: bool,
/// Ignored with a single transaction, which `pg_restore` cannot split.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPsqlOptions {
pub single_transaction: bool,
pub stop_on_error: bool,
}
/// Switches that `mysqldump` turns on by default (`--opt`) only take a flag when turned off.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqldumpOptions {
/// Empty: every database.
pub databases: Vec<String>,
/// Only with exactly one database.
pub tables: Vec<String>,
pub add_drop_table: bool,
pub disable_keys: bool,
pub add_locks: bool,
pub add_drop_trigger: bool,
pub no_data: bool,
pub complete_insert: bool,
pub create_options: bool,
pub routines: bool,
pub events: bool,
/// A consistent InnoDB snapshot without locks; needs no RELOAD privilege.
pub single_transaction: bool,
/// Wins over `single_transaction`.
pub lock_all_tables: bool,
/// `None`: the client has no `--masking-policies`.
pub masking_policies: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbMysqlOptions {
/// Empty: the databases the dump names.
pub database: String,
/// Runs the remaining statements after an error.
pub force: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
pub enum DbToolJob {
PgDump {
file: String,
options: DbPgDumpOptions,
},
/// `file`: an archive, or a directory archive.
PgRestore {
file: String,
options: DbPgRestoreOptions,
},
Psql {
file: String,
options: DbPsqlOptions,
},
Mysqldump {
file: String,
options: DbMysqldumpOptions,
},
/// `file` goes to the standard input.
Mysql {
file: String,
options: DbMysqlOptions,
},
}
impl DbToolJob {
pub fn tool(&self) -> DbTool {
match self {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
DbToolJob::Mysqldump { .. } => DbTool::Mysqldump,
DbToolJob::Mysql { .. } => DbTool::Mysql,
}
}
/// The file piped to the tool's standard input.
pub fn input(&self) -> Option<&str> {
match self {
DbToolJob::Mysql { file, .. } if !file.is_empty() => Some(file),
_ => None,
}
}
/// Refuses names that the tool would read as options: `mysqldump` takes databases and tables
/// as plain arguments.
pub fn check(&self) -> IdeResult<()> {
if let DbToolJob::Mysqldump { options, .. } = self
&& let Some(name) = options.databases.iter().chain(&options.tables).find(|n| n.trim().starts_with('-'))
{
return Err(IdeError::invalid(format!("mysqldump cannot dump a database or table named {name}")));
}
Ok(())
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
DbToolJob::Mysqldump { file, options } => mysqldump(options, file),
DbToolJob::Mysql { options, .. } => mysql(options),
}
}
}
fn flag(on: bool, flag: &str) -> Option<String> {
on.then(|| flag.to_owned())
}
fn content(c: DbDumpContent) -> Option<String> {
match c {
DbDumpContent::All => None,
DbDumpContent::SchemaOnly => Some("--schema-only".into()),
DbDumpContent::DataOnly => Some("--data-only".into()),
}
}
fn each(names: &[String], option: &str) -> impl Iterator<Item = String> {
names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}"))
}
fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
let plain = o.format == DbDumpFormat::Plain;
let format = match o.format {
DbDumpFormat::Plain => "p",
DbDumpFormat::Custom => "c",
DbDumpFormat::Directory => "d",
DbDumpFormat::Tar => "t",
};
let mut args = vec![format!("--format={format}"), format!("--file={file}")];
args.extend(match o.statements {
DbDumpStatements::Copy => None,
DbDumpStatements::Inserts => Some("--inserts".to_owned()),
DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()),
});
args.extend(content(o.content));
args.extend(each(&o.schemas, "schema"));
args.extend(each(&o.tables, "table"));
args.extend(each(&o.exclude_tables, "exclude-table"));
args.extend(flag(plain && o.clean, "--clean"));
args.extend(flag(plain && o.clean && o.if_exists, "--if-exists"));
args.extend(flag(plain && o.create, "--create"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
if o.format == DbDumpFormat::Directory && o.jobs > 1 {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
args
}
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.create, "--create"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.exit_on_error, "--exit-on-error"));
if o.jobs > 1 && !o.single_transaction {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
if !file.is_empty() {
args.push(file.to_owned());
}
args
}
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
// `~/.psqlrc` could switch databases or change settings before the dump runs.
let mut args = vec!["--no-psqlrc".to_owned()];
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
args
}
fn names(list: &[String]) -> impl Iterator<Item = String> {
list.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(str::to_owned)
}
fn mysqldump(o: &DbMysqldumpOptions, file: &str) -> Vec<String> {
let skip = |on: bool, option: &str| (!on).then(|| format!("--skip-{option}"));
let mut args = vec![format!("--result-file={file}")];
args.extend(skip(o.add_drop_table, "add-drop-table"));
args.extend(skip(o.disable_keys, "disable-keys"));
args.extend(skip(o.add_locks, "add-locks"));
args.extend(skip(o.create_options, "create-options"));
args.extend(flag(o.add_drop_trigger, "--add-drop-trigger"));
args.extend(flag(o.no_data, "--no-data"));
args.extend(flag(o.complete_insert, "--complete-insert"));
args.extend(flag(o.routines, "--routines"));
args.extend(flag(o.events, "--events"));
args.extend(flag(o.lock_all_tables, "--lock-all-tables"));
args.extend(flag(!o.lock_all_tables && o.single_transaction, "--single-transaction"));
// On by default where it exists; reading the policies needs privileges most users lack.
args.extend(flag(o.masking_policies == Some(false), "--skip-masking-policies"));
// Tablespace statements need the PROCESS privilege and rarely matter in a dump.
args.push("--no-tablespaces".into());
args.push("--verbose".into());
let databases: Vec<String> = names(&o.databases).collect();
match databases.as_slice() {
[] => args.push("--all-databases".into()),
[one] => {
args.push(one.clone());
args.extend(names(&o.tables));
}
_ => {
args.push("--databases".into());
args.extend(databases);
}
}
args
}
fn mysql(o: &DbMysqlOptions) -> Vec<String> {
let database = o.database.trim();
let mut args: Vec<String> = (!database.is_empty()).then(|| format!("--database={database}")).into_iter().collect();
args.extend(flag(o.force, "--force"));
args
}
/// The command as a shell would need it typed: the dialogs' preview. `input` is piped in.
pub fn command_line(program: &Path, args: &[String], input: Option<&str>) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
} else {
format!("'{}'", s.replace('\'', "'\\''"))
}
};
let line = std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ");
match input {
Some(file) => format!("{line} < {}", quote(file)),
None => line,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn dump() -> DbPgDumpOptions {
DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
}
}
fn restore() -> DbPgRestoreOptions {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
}
}
fn args(job: DbToolJob) -> Vec<String> {
job.args()
}
#[test]
fn dumps_plain_sql_with_copy_by_default() {
let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() };
assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]);
}
#[test]
fn turns_lists_and_switches_into_flags() {
let options = DbPgDumpOptions {
statements: DbDumpStatements::ColumnInserts,
content: DbDumpContent::DataOnly,
schemas: vec!["public".into(), "audit".into()],
tables: vec!["public.orders".into()],
exclude_tables: vec!["public.log_*".into()],
clean: true,
if_exists: true,
create: true,
no_owner: true,
..dump()
};
assert_eq!(
args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }),
[
"--format=p",
"--file=/tmp/x.sql",
"--column-inserts",
"--data-only",
"--schema=public",
"--schema=audit",
"--table=public.orders",
"--exclude-table=public.log_*",
"--clean",
"--if-exists",
"--create",
"--no-owner",
"--verbose",
]
);
}
#[test]
fn leaves_drop_and_create_to_the_restore_of_an_archive() {
let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() };
let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options });
assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}");
}
#[test]
fn runs_parallel_jobs_only_where_the_tool_can() {
let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() };
assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into()));
let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir };
assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into()));
let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single });
assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs")));
}
#[test]
fn restores_the_archive_named_last_and_stops_on_the_first_error() {
assert_eq!(
args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }),
["--exit-on-error", "--verbose", "/tmp/shop.dump"]
);
}
#[test]
fn creates_the_database_of_the_archive_when_asked() {
let options = DbPgRestoreOptions { create: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options });
assert_eq!(a, ["--create", "--exit-on-error", "--verbose", "/tmp/shop.dump"]);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
assert_eq!(a, ["--exit-on-error", "--verbose"]);
}
#[test]
fn runs_a_sql_file_in_one_transaction_that_stops_on_error() {
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
assert_eq!(
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
);
}
#[test]
fn quotes_what_a_shell_would_split() {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
None,
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
let line = command_line(Path::new("mysql"), &["--force".into()], Some("/tmp/my dump.sql"));
assert_eq!(line, "mysql --force < '/tmp/my dump.sql'");
}
fn mysqldump_options() -> DbMysqldumpOptions {
DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
}
}
#[test]
fn mysqldump_flags_only_what_differs_from_its_defaults() {
let job = DbToolJob::Mysqldump { file: "/tmp/shop.sql".into(), options: mysqldump_options() };
assert_eq!(
args(job),
["--result-file=/tmp/shop.sql", "--single-transaction", "--no-tablespaces", "--verbose", "shop"]
);
let options = DbMysqldumpOptions {
add_drop_table: false,
create_options: false,
routines: true,
lock_all_tables: true,
masking_policies: Some(false),
..mysqldump_options()
};
let a = args(DbToolJob::Mysqldump { file: "/tmp/x.sql".into(), options });
for expected in ["--skip-add-drop-table", "--skip-create-options", "--routines", "--lock-all-tables"] {
assert!(a.contains(&expected.to_owned()), "{expected} missing from {a:?}");
}
assert!(a.contains(&"--skip-masking-policies".to_owned()), "{a:?}");
assert!(!a.contains(&"--single-transaction".to_owned()), "{a:?}");
}
#[test]
fn mysqldump_names_tables_only_of_a_single_database() {
let tables = vec!["orders".to_owned(), "items".to_owned()];
let one = DbMysqldumpOptions { tables: tables.clone(), ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: one }).ends_with(&[
"shop".into(),
"orders".into(),
"items".into()
]));
let two = DbMysqldumpOptions { databases: vec!["a".into(), "b".into()], tables, ..mysqldump_options() };
assert!(args(DbToolJob::Mysqldump { file: "f".into(), options: two }).ends_with(&[
"--databases".into(),
"a".into(),
"b".into()
]));
let all = DbMysqldumpOptions { databases: vec![], ..mysqldump_options() };
assert_eq!(args(DbToolJob::Mysqldump { file: "f".into(), options: all }).last().unwrap(), "--all-databases");
}
#[test]
fn mysqldump_refuses_names_it_would_read_as_options() {
let options = DbMysqldumpOptions { tables: vec!["--result-file=/etc/x".into()], ..mysqldump_options() };
assert!(DbToolJob::Mysqldump { file: "f".into(), options }.check().is_err());
assert!(DbToolJob::Mysqldump { file: "f".into(), options: mysqldump_options() }.check().is_ok());
}
#[test]
fn mysql_reads_the_dump_from_its_standard_input() {
let job = DbToolJob::Mysql {
file: "/tmp/shop.sql".into(),
options: DbMysqlOptions { database: " shop ".into(), force: true },
};
assert_eq!(args(job.clone()), ["--database=shop", "--force"]);
assert_eq!(job.input(), Some("/tmp/shop.sql"));
let none =
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: String::new(), force: false } };
assert!(args(none.clone()).is_empty() && none.input().is_none());
}
#[test]
fn reads_the_job_the_dialog_sends() {
let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#;
let job: DbToolJob = serde_json::from_str(json).unwrap();
assert_eq!(job.tool(), DbTool::Psql);
}
}
-846
Переглянути файл
@@ -1,846 +0,0 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`, `mysqldump`, `mysql`): finding
//! installed copies, the arguments and environment that connect them like the data source, and
//! running them.
mod jobs;
pub use jobs::*;
use crate::source::{DataSource, DbDriver, DbSslMode};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbTool {
PgDump,
PgRestore,
Psql,
Mysqldump,
Mysql,
}
impl DbTool {
pub fn program(self) -> &'static str {
self.programs()[0]
}
/// Executable names, MariaDB's own after MySQL's.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
DbTool::Mysqldump => &["mysqldump", "mariadb-dump"],
DbTool::Mysql => &["mysql", "mariadb"],
}
}
pub fn driver(self) -> DbDriver {
match self {
DbTool::PgDump | DbTool::PgRestore | DbTool::Psql => DbDriver::Postgres,
DbTool::Mysqldump | DbTool::Mysql => DbDriver::Mysql,
}
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`, `mariadb-dump`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
self.programs().iter().any(|p| {
stem.strip_prefix(p).is_some_and(|rest| {
let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest);
digits.chars().all(|c| c.is_ascii_digit())
})
})
}
}
/// Whether `executable` is MariaDB's client (`mariadb`, `mariadb-dump`), whose SSL options differ
/// from MySQL's.
fn is_mariadb(executable: &Path) -> bool {
executable.file_stem().and_then(OsStr::to_str).is_some_and(|s| s.starts_with("mariadb"))
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
pub struct ToolInstall {
pub path: String,
/// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`.
pub version: String,
}
/// A line the tool wrote.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolLine")]
pub struct ToolLine {
pub stderr: bool,
pub text: String,
}
/// Directories holding the tools of `driver` that are often missing from `PATH`, by platform.
fn known_dirs(driver: DbDriver) -> Vec<PathBuf> {
let mysql = driver == DbDriver::Mysql;
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
let kegs: &[&str] = if mysql { &["mysql-client", "mysql", "mariadb"] } else { &["libpq", "postgresql"] };
for keg in kegs {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
if mysql {
dirs.push(PathBuf::from("/usr/local/mysql/bin"));
} else {
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "")
.into_iter()
.map(|d| d.join("bin")),
);
}
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let base = PathBuf::from(base);
// MySQL installs to `MySQL\MySQL Server 8.4`, MariaDB to `MariaDB 11.4`.
let roots: &[(&str, &str)] =
if mysql { &[("MySQL", "MySQL"), ("", "MariaDB")] } else { &[("PostgreSQL", "")] };
for (dir, prefix) in roots {
dirs.extend(children(&base.join(dir), prefix).into_iter().map(|d| d.join("bin")));
}
}
}
} else if !mysql {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
dirs
}
/// Subdirectories of `parent` whose name starts with `prefix`, newest version first.
fn children(parent: &Path, prefix: &str) -> Vec<PathBuf> {
let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() };
let mut dirs: Vec<PathBuf> = entries
.flatten()
.filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix)))
.map(|e| e.path())
.filter(|p| p.is_dir())
.collect();
dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy())));
dirs
}
/// The numbers in `text`, for comparing versions (`17.2` after `9.6`).
fn version_key(text: &str) -> Vec<u32> {
text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect()
}
/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first.
/// Blocking: runs each one's `--version`.
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs(tool.driver()));
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
for program in tool.programs() {
let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue };
let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone());
if seen.contains(&real) {
continue;
}
seen.push(real);
if let Ok(version) = version_of(&found) {
out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version });
}
}
}
out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version)));
out
}
/// The first line `path --version` prints. Blocking.
pub fn version_of(path: &Path) -> IdeResult<String> {
let (ok, text) = capture(path, "--version")?;
match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) {
Some(line) if ok => Ok(line.to_owned()),
_ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))),
}
}
/// The long options `path --help` lists (`masking-policies` for `--masking-policies`), so a
/// dialog offers only options this copy knows. Blocking.
pub fn options_of(path: &Path) -> IdeResult<Vec<String>> {
let (_, text) = capture(path, "--help")?;
Ok(help_options(&text))
}
fn help_options(help: &str) -> Vec<String> {
let mut out: Vec<String> = help
.lines()
.filter(|l| l.starts_with(' ') && l.trim_start().starts_with('-'))
.filter_map(|l| {
let at = l.find("--")?;
let name: String =
l[at + 2..].chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_').collect();
(!name.is_empty()).then_some(name)
})
.collect();
out.sort();
out.dedup();
out
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
return Err(IdeError::not_found(format!("{} does not exist", path.display())));
}
let mut cmd = std::process::Command::new(path);
cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
ide_core::process::prepare(&mut cmd);
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let reader = std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = std::io::Read::read_to_end(&mut stdout, &mut buf);
buf
});
let deadline = std::time::Instant::now() + Duration::from_secs(5);
let status = loop {
if let Some(status) = child.try_wait()? {
break status;
}
if std::time::Instant::now() > deadline {
let _ = child.kill();
let _ = child.wait();
return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display())));
}
std::thread::sleep(Duration::from_millis(20));
};
let out = reader.join().unwrap_or_default();
Ok((status.success(), String::from_utf8_lossy(&out).into_owned()))
}
/// What made a dump, read from its first bytes (a directory: its `toc.dat`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpKind {
/// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`.
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: `mysql`.
MysqlSql,
Unknown,
}
/// What a restore needs to know about a dump before it runs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbDumpInfo")]
pub struct DumpInfo {
pub kind: DbDumpKind,
/// An SQL dump that runs `CREATE DATABASE` itself: `mysqldump --databases` / `--all-databases`,
/// or `pg_dump --create`. Archives say `false`; `pg_restore --create` decides for them.
pub creates_database: bool,
}
/// Blocking: reads at most the first 64 KiB, where both tools write their `CREATE DATABASE`.
pub fn dump_info(path: &Path) -> IdeResult<DumpInfo> {
use std::io::Read;
if path.is_dir() {
let kind = if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown };
return Ok(DumpInfo { kind, creates_database: false });
}
let mut head = Vec::with_capacity(64 * 1024);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(64 * 1024)
.read_to_end(&mut head)?;
Ok(info_of(&head))
}
fn info_of(head: &[u8]) -> DumpInfo {
let kind = kind_of(head);
let sql = matches!(kind, DbDumpKind::PostgresSql | DbDumpKind::MysqlSql);
let creates_database = sql && String::from_utf8_lossy(head).lines().any(|l| l.starts_with("CREATE DATABASE "));
DumpInfo { kind, creates_database }
}
fn kind_of(head: &[u8]) -> DbDumpKind {
// A tar archive keeps `toc.dat` first; its name starts the 512-byte header.
if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") {
return DbDumpKind::PostgresArchive;
}
let text = String::from_utf8_lossy(head);
let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect();
if comments.iter().any(|l| l.contains("PostgreSQL database dump")) {
DbDumpKind::PostgresSql
} else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) {
DbDumpKind::MysqlSql
} else {
DbDumpKind::Unknown
}
}
/// Arguments and environment that connect `tool` at `executable` to `source` (already resolved,
/// through its tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, executable: &Path, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
if tool.driver() == DbDriver::Mysql {
return (mysql_connection(tool, executable, source), Vec::new());
}
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432)));
if !source.user.trim().is_empty() {
args.push(format!("--username={}", source.user.trim()));
}
if !source.database.is_empty() {
args.push(format!("--dbname={}", dbname_arg(&source.database)));
}
// Without a terminal a password prompt would wait forever: fail instead.
args.push("--no-password".into());
let mut env = vec![
("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())),
(
"PGSSLMODE".to_owned(),
match source.ssl {
DbSslMode::Disable => "disable",
DbSslMode::Prefer => "prefer",
DbSslMode::Require => "require",
DbSslMode::VerifyCa => "verify-ca",
DbSslMode::VerifyFull => "verify-full",
}
.to_owned(),
),
];
for (var, file) in [
("PGSSLROOTCERT", &source.ssl_ca_file),
("PGSSLCERT", &source.ssl_cert_file),
("PGSSLKEY", &source.ssl_key_file),
] {
if !file.trim().is_empty() {
env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned()));
}
}
if source.read_only {
env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned()));
}
(args, env)
}
/// The database is the job's: a dump may name several.
fn mysql_connection(tool: DbTool, executable: &Path, source: &DataSource) -> Vec<String> {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(3306)));
if !source.user.trim().is_empty() {
args.push(format!("--user={}", source.user.trim()));
}
// `localhost` would otherwise mean the Unix socket, not the port or the tunnel.
args.push("--protocol=TCP".into());
if is_mariadb(executable) {
let flags: &[&str] = match source.ssl {
DbSslMode::Disable => &["--skip-ssl"],
DbSslMode::Prefer => &["--skip-ssl-verify-server-cert"],
DbSslMode::Require => &["--ssl", "--skip-ssl-verify-server-cert"],
DbSslMode::VerifyCa | DbSslMode::VerifyFull => &["--ssl", "--ssl-verify-server-cert"],
};
args.extend(flags.iter().map(|f| f.to_string()));
} else {
let mode = match source.ssl {
DbSslMode::Disable => "DISABLED",
DbSslMode::Prefer => "PREFERRED",
DbSslMode::Require => "REQUIRED",
DbSslMode::VerifyCa => "VERIFY_CA",
DbSslMode::VerifyFull => "VERIFY_IDENTITY",
};
args.push(format!("--ssl-mode={mode}"));
}
for (flag, file) in
[("--ssl-ca", &source.ssl_ca_file), ("--ssl-cert", &source.ssl_cert_file), ("--ssl-key", &source.ssl_key_file)]
{
if !file.trim().is_empty() {
args.push(format!("{flag}={}", ide_ssh::expand(file.trim()).to_string_lossy()));
}
}
if tool == DbTool::Mysql && source.read_only {
args.push("--init-command=SET SESSION TRANSACTION READ ONLY".into());
}
args
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
} else {
name.to_owned()
}
}
/// A MySQL client option file holding the password, readable by the user only; deleted on drop.
struct SecretFile(PathBuf);
impl SecretFile {
fn mysql_password(password: &str) -> IdeResult<Self> {
use std::io::Write;
let path = std::env::temp_dir().join(format!("openidea-mysql-{}.cnf", uuid::Uuid::new_v4()));
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&path)?;
let secret = SecretFile(path);
let escaped = password.replace('\\', "\\\\").replace('"', "\\\"");
writeln!(file, "[client]\npassword=\"{escaped}\"")?;
Ok(secret)
}
/// `mysqldump` / `mysql` accept it only as their first argument.
fn arg(&self) -> String {
format!("--defaults-extra-file={}", self.0.display())
}
}
impl Drop for SecretFile {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.0);
}
}
/// How a tool is started: connection arguments, then the job's, the environment, and the file
/// piped to its standard input. Keep it until the tool exits: it owns the password file.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
pub input: Option<PathBuf>,
_secret: Option<SecretFile>,
}
/// The command for `job` at `executable` against `source`. The password goes in `PGPASSWORD` or
/// a MySQL option file, never in the arguments, which other users of the machine can read in the
/// process list.
pub fn prepare(job: &DbToolJob, executable: &Path, source: &DataSource, password: Option<&str>) -> IdeResult<Prepared> {
job.check()?;
let tool = job.tool();
let (mut args, mut env) = connection(tool, executable, source);
args.extend(job.args());
let mut secret = None;
match password.filter(|p| !p.is_empty()) {
Some(p) if tool.driver() == DbDriver::Mysql => {
let file = SecretFile::mysql_password(p)?;
args.insert(0, file.arg());
secret = Some(file);
}
Some(p) => env.push(("PGPASSWORD".into(), p.to_owned())),
None => {}
}
Ok(Prepared { args, env, input: job.input().map(PathBuf::from), _secret: secret })
}
/// Runs `program` until it exits, passing its output in batches; `input` is piped to its standard
/// input. Returns the exit code (`None`: ended by a signal). Cancelling kills it and everything it
/// started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
input: Option<&Path>,
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let stdin = match input {
Some(path) => Stdio::from(
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?,
),
None => Stdio::null(),
};
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(stdin)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
ide_core::process::prepare(cmd.as_std_mut());
ide_core::process::own_group(cmd.as_std_mut());
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?;
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
if let Some(out) = child.stdout.take() {
forward(out, false, tx.clone());
}
if let Some(err) = child.stderr.take() {
forward(err, true, tx);
}
let mut batch = Vec::new();
let mut tick = tokio::time::interval(Duration::from_millis(100));
loop {
tokio::select! {
line = rx.recv() => match line {
Some(line) => {
batch.push(line);
if batch.len() >= 500 {
on_output(std::mem::take(&mut batch));
}
}
None => break,
},
_ = tick.tick() => {
if !batch.is_empty() {
on_output(std::mem::take(&mut batch));
}
}
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
}
}
if !batch.is_empty() {
on_output(batch);
}
let status = tokio::select! {
status = child.wait() => status?,
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
};
Ok(status.code())
}
fn forward(
pipe: impl AsyncRead + Unpin + Send + 'static,
stderr: bool,
tx: tokio::sync::mpsc::UnboundedSender<ToolLine>,
) {
tokio::spawn(async move {
let mut reader = BufReader::new(pipe);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf).await {
Ok(0) | Err(_) => break,
Ok(_) => {
let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned();
if tx.send(ToolLine { stderr, text }).is_err() {
break;
}
}
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
fn pg() -> DataSource {
DataSource {
driver: DbDriver::Postgres,
host: "db.example.test".into(),
port: Some(6543),
user: "app".into(),
database: "shop".into(),
..DataSource::default()
}
}
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, Path::new("pg_dump"), &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
}
#[test]
fn a_database_named_like_connection_parameters_stays_a_name() {
for (name, arg) in [
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) =
connection(DbTool::PgDump, Path::new("pg_dump"), &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, Path::new("psql"), &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, Path::new("pg_restore"), &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
#[test]
fn only_the_tool_itself_is_accepted() {
for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] {
assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}");
}
for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] {
assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}");
}
}
#[test]
fn mysql_tools_accept_mariadb_names_only_for_themselves() {
assert!(DbTool::Mysqldump.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(DbTool::Mysql.is_program(Path::new("/opt/homebrew/opt/mysql-client/bin/mysql")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mysqldump")));
assert!(!DbTool::Mysql.is_program(Path::new("/usr/bin/mariadb-dump")));
assert!(!DbTool::Mysqldump.is_program(Path::new("/usr/bin/mysqlpump")));
}
#[test]
fn mysql_connects_over_tcp_with_the_ssl_flags_of_its_client() {
let source = DataSource {
driver: DbDriver::Mysql,
host: "localhost".into(),
port: None,
user: "app".into(),
read_only: true,
..DataSource::default()
};
let (args, env) = connection(DbTool::Mysql, Path::new("/usr/bin/mysql"), &source);
assert_eq!(
args,
[
"--host=localhost",
"--port=3306",
"--user=app",
"--protocol=TCP",
"--ssl-mode=PREFERRED",
"--init-command=SET SESSION TRANSACTION READ ONLY"
]
);
assert!(env.is_empty());
let (args, _) = connection(DbTool::Mysqldump, Path::new("/usr/bin/mariadb-dump"), &source);
assert!(args.contains(&"--skip-ssl-verify-server-cert".to_owned()));
assert!(!args.iter().any(|a| a.starts_with("--ssl-mode") || a.starts_with("--init-command")));
}
#[test]
fn the_password_file_is_private_and_removed() {
let file = SecretFile::mysql_password(r#"p"a\ss"#).unwrap();
let path = file.arg().trim_start_matches("--defaults-extra-file=").to_owned();
let text = std::fs::read_to_string(&path).unwrap();
assert_eq!(text, "[client]\npassword=\"p\\\"a\\\\ss\"\n");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
}
drop(file);
assert!(!Path::new(&path).exists());
}
#[test]
fn reads_long_options_from_help() {
let help = "Usage: mysqldump [OPTIONS]\n -A, --all-databases Dump all.\n --masking-policies Dump masking\n policies (--not-an-option).\n -y, --no-tablespaces \n -f, --file=FILENAME output file\n";
assert_eq!(help_options(help), ["all-databases", "file", "masking-policies", "no-tablespaces"]);
}
#[cfg(unix)]
#[tokio::test]
async fn pipes_the_input_file() {
let file = std::env::temp_dir().join(format!("openidea-input-{}", uuid::Uuid::new_v4()));
std::fs::write(&file, "from the file\n").unwrap();
let mut lines = Vec::new();
run(Path::new("/bin/cat"), &[], &[], Some(&file), &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
std::fs::remove_file(&file).unwrap();
assert_eq!(lines, [ToolLine { stderr: false, text: "from the file".into() }]);
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql);
assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn sees_a_dump_that_creates_its_own_database() {
let one = b"-- MySQL dump 10.13\n--\n-- Host: localhost Database: shop\nCREATE TABLE `items` (id int);\n";
assert!(!info_of(one).creates_database);
let several = b"-- MySQL dump 10.13\n--\n-- Current Database: `shop`\n--\n\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ `shop`;\nUSE `shop`;\n";
assert!(info_of(several).creates_database);
let pg = b"--\n-- PostgreSQL database dump\n--\nSET client_encoding = 'UTF8';\nCREATE DATABASE shop WITH TEMPLATE = template0;\n\\connect shop\n";
assert_eq!(info_of(pg), DumpInfo { kind: DbDumpKind::PostgresSql, creates_database: true });
assert!(!info_of(b"CREATE DATABASE x;\n").creates_database, "only for a dump the tools wrote");
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
}
#[cfg(unix)]
#[tokio::test]
async fn streams_both_pipes_and_reports_the_exit_code() {
let mut lines = Vec::new();
let code = run(
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
None,
&CancellationToken::new(),
|batch| lines.extend(batch),
)
.await
.unwrap();
assert_eq!(code, Some(3));
assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() }));
assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() }));
}
#[cfg(unix)]
#[tokio::test]
async fn cancelling_stops_the_process() {
let cancel = CancellationToken::new();
let stop = cancel.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], None, &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether it got a password
/// from `PGPASSWORD` or a MySQL option file.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
concat!(
"#!/bin/sh\n",
"for a in \"$@\"; do echo \"arg:$a\"; case \"$a\" in --defaults-extra-file=*)\n",
" grep -q '^password=' \"${a#*=}\" && echo env:set;; esac; done\n",
"[ -n \"$PGPASSWORD\" ] && echo env:set\n",
"exit 0\n",
),
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
path
}
#[cfg(unix)]
#[tokio::test]
async fn the_password_never_reaches_the_arguments() {
const SECRET: &str = "s3cret-pass-do-not-leak";
let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("out.sql").to_string_lossy().into_owned();
let jobs = [
DbToolJob::PgDump {
file: file.clone(),
options: DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec!["public".into()],
tables: vec![],
exclude_tables: vec![],
clean: true,
if_exists: true,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
},
DbToolJob::Psql {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
DbToolJob::Mysqldump {
file: file.clone(),
options: DbMysqldumpOptions {
databases: vec!["shop".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: None,
},
},
DbToolJob::Mysql { file: String::new(), options: DbMysqlOptions { database: "shop".into(), force: false } },
];
for job in jobs {
let mysql = job.tool().driver() == DbDriver::Mysql;
let source = if mysql { DataSource { driver: DbDriver::Mysql, ..pg() } } else { pg() };
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &program, &source, Some(SECRET)).unwrap();
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
assert!(!mysql || prepared.env.is_empty(), "{:?}", prepared.env);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, None, &CancellationToken::new(), |b| lines.extend(b))
.await
.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
let database = if mysql { "shop" } else { "--dbname=shop" };
assert!(text.iter().any(|l| l.strip_prefix("arg:").is_some_and(|a| a.ends_with(database))), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password: {text:?}");
if mysql {
let file = prepared.args[0].trim_start_matches("--defaults-extra-file=").to_owned();
drop(prepared);
assert!(!Path::new(&file).exists(), "the password file outlives the run");
}
}
std::fs::remove_dir_all(&dir).unwrap();
}
}
-67
Переглянути файл
@@ -231,70 +231,3 @@ async fn servers_that_advertise_deprecate_eof_but_send_legacy_eof_packets() -> I
assert_eq!(r.rows, vec![vec![Some("a".into())], vec![Some("b".into())]]);
Ok(())
}
/// `mysqldump` into a file and `mysql` reading it back, with the data source's password.
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{DbMysqlOptions, DbMysqldumpOptions, DbTool, DbToolJob, find_installs};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp, "").await else { return Ok(()) };
let (Some(dump), Some(client)) =
(find_installs(DbTool::Mysqldump).into_iter().next(), find_installs(DbTool::Mysql).into_iter().next())
else {
return Ok(());
};
let c = CancellationToken::new();
for stmt in [
"DROP DATABASE IF EXISTS oi_dump_src",
"DROP DATABASE IF EXISTS oi_dump_dst",
"CREATE DATABASE oi_dump_src",
"CREATE DATABASE oi_dump_dst",
"CREATE TABLE oi_dump_src.items (id INT PRIMARY KEY, tag VARCHAR(20))",
"INSERT INTO oi_dump_src.items VALUES (1, 'dumped')",
] {
db.execute("m", stmt, 1, &c).await?;
}
let file = tmp.path().join("src.sql").to_string_lossy().into_owned();
let run = |executable: String, job: DbToolJob| {
let db = &db;
async move {
let mut lines = Vec::new();
let code =
db.run_tool("m", executable.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
IdeResult::Ok(())
}
};
let masking = ide_db::tools::options_of(dump.path.as_ref())?.iter().any(|o| o == "masking-policies");
let options = DbMysqldumpOptions {
databases: vec!["oi_dump_src".into()],
tables: vec![],
add_drop_table: true,
disable_keys: true,
add_locks: true,
add_drop_trigger: false,
no_data: false,
complete_insert: false,
create_options: true,
routines: false,
events: false,
single_transaction: true,
lock_all_tables: false,
masking_policies: masking.then_some(false),
};
run(dump.path.clone(), DbToolJob::Mysqldump { file: file.clone(), options: options.clone() }).await?;
assert!(!ide_db::tools::dump_info(file.as_ref())?.creates_database, "one database: restored into a chosen one");
let both = tmp.path().join("both.sql").to_string_lossy().into_owned();
let two = DbMysqldumpOptions { databases: vec!["oi_dump_src".into(), "oi_dump_dst".into()], ..options };
run(dump.path, DbToolJob::Mysqldump { file: both.clone(), options: two }).await?;
assert!(ide_db::tools::dump_info(both.as_ref())?.creates_database, "several databases: created by the dump");
let restore = DbMysqlOptions { database: "oi_dump_dst".into(), force: false };
run(client.path, DbToolJob::Mysql { file, options: restore }).await?;
let r = db.execute("m", "SELECT tag FROM oi_dump_dst.items", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("dumped"));
for stmt in ["DROP DATABASE oi_dump_src", "DROP DATABASE oi_dump_dst"] {
db.execute("m", stmt, 1, &c).await?;
}
Ok(())
}
-76
Переглянути файл
@@ -228,79 +228,3 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
Ok(())
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
Ok(())
}
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{
DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool,
DbToolJob, find_installs,
};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let server = db.server_version("p").await? / 10000;
let major = |t: DbTool| {
find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::<u32>().ok())
};
// Other major versions write or refuse what this server needs; the dialogs warn about that instead.
if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) {
return Ok(());
}
create_schemas(&db).await;
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?;
db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?;
let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned();
let dump = |format, file: String, schema: &str| DbToolJob::PgDump {
file,
options: DbPgDumpOptions {
format,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![schema.into()],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
};
let archive = file("a.dump");
run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?;
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
create: false,
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
};
run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?;
let script = file("b.sql");
run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?;
let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true };
run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?;
let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b"));
db.disconnect("p:oi_restore").await;
db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?;
Ok(())
}
+1 -33
Переглянути файл
@@ -24,16 +24,6 @@ pub enum DockerEndpoint {
Tcp { host: String, tls_cert_dir: Option<String> },
/// A named `docker context`.
Context { name: String },
/// A daemon on the host of an SSH configuration (Settings › Tools › SSH Configurations),
/// reached with the IDE's own SSH client and its saved credentials. The host resolves it to
/// a local [`DockerEndpoint::Tcp`] tunnel before running docker; unresolved, the CLI is
/// pointed at an address it rejects rather than at another daemon.
Ssh { config: String },
}
/// What an unresolved [`DockerEndpoint::Ssh`] gives the CLI: an error, never a fallback daemon.
fn unresolved_ssh(config: &str) -> String {
format!("ssh-configuration://{}", config.trim())
}
impl DockerEndpoint {
@@ -65,7 +55,6 @@ impl DockerEndpoint {
args
}
Self::Context { name } => vec!["--context".into(), name.trim().to_owned()],
Self::Ssh { config } => vec!["--host".into(), unresolved_ssh(config)],
}
}
@@ -112,11 +101,6 @@ impl DockerEndpoint {
set("DOCKER_HOST", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
Self::Ssh { config } => {
set("DOCKER_HOST", unresolved_ssh(config));
set("DOCKER_CONTEXT", String::new());
set("DOCKER_TLS_VERIFY", String::new());
}
}
env
}
@@ -127,13 +111,8 @@ impl DockerEndpoint {
Self::Socket { path } => path.trim().is_empty(),
Self::Tcp { host, .. } => host.trim().is_empty(),
Self::Context { name } => name.trim().is_empty() || name.trim().starts_with('-'),
Self::Ssh { config } => config.trim().is_empty(),
};
if empty {
Err(IdeError::invalid("the Docker connection needs a socket, host, context or SSH configuration"))
} else {
Ok(())
}
if empty { Err(IdeError::invalid("the Docker connection needs a socket, host or context")) } else { Ok(()) }
}
}
@@ -346,17 +325,6 @@ fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
mod tests {
use super::*;
#[test]
fn an_unresolved_ssh_endpoint_never_falls_back_to_another_daemon() {
let ssh = DockerEndpoint::Ssh { config: "box".into() };
assert_eq!(ssh.global_args(), ["--host", "ssh-configuration://box"]);
let env = ssh.env_vars();
assert_eq!((env["DOCKER_HOST"].as_str(), env["DOCKER_CONTEXT"].as_str()), ("ssh-configuration://box", ""));
assert!(ssh.validate().is_ok());
assert!(DockerEndpoint::Ssh { config: " ".into() }.validate().is_err());
assert!(!crate::endpoint_is_local(&ssh).unwrap());
}
#[test]
fn endpoint_args() {
assert!(DockerEndpoint::Default.global_args().is_empty());
+1 -2
Переглянути файл
@@ -142,7 +142,7 @@ pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
}
const FMT: &str = "{{json .}}";
let (containers, images, volumes, networks) = std::thread::scope(|s| {
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", PS_FORMAT], QUICK));
let c = s.spawn(|| run(ep, &["ps", "--all", "--no-trunc", "--format", FMT], QUICK));
let i = s.spawn(|| run(ep, &["image", "ls", "--no-trunc", "--format", FMT], QUICK));
let v = s.spawn(|| run(ep, &["volume", "ls", "--format", FMT], QUICK));
let n = s.spawn(|| run(ep, &["network", "ls", "--no-trunc", "--format", FMT], QUICK));
@@ -483,7 +483,6 @@ pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
|name| context_host(&DockerEndpoint::Default, name),
)?,
DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
DockerEndpoint::Ssh { .. } => return Ok(false),
};
Ok(daemon_url_is_local(&url))
}
+1 -11
Переглянути файл
@@ -226,16 +226,6 @@ fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> +
})
}
/// The `docker ps --format` template: only the fields [`RawContainer`] reads. `{{json .}}`
/// would also include `Size`, which makes the daemon compute every container's writable
/// layer and can take tens of seconds.
pub const PS_FORMAT: &str = concat!(
r#"{"ID":{{json .ID}},"Names":{{json .Names}},"Image":{{json .Image}},"#,
r#""Command":{{json .Command}},"State":{{json .State}},"Status":{{json .Status}},"#,
r#""Ports":{{json .Ports}},"CreatedAt":{{json .CreatedAt}},"Labels":{{json .Labels}},"#,
r#""Mounts":{{json .Mounts}},"Networks":{{json .Networks}}}"#,
);
#[derive(Deserialize, Default)]
#[serde(rename_all = "PascalCase", default)]
struct RawContainer {
@@ -257,7 +247,7 @@ fn split_csv(raw: &str) -> Vec<String> {
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
}
/// `docker ps -a --no-trunc --format` [`PS_FORMAT`] (or `'{{json .}}'`).
/// `docker ps -a --no-trunc --format '{{json .}}'`.
pub fn parse_containers(text: &str) -> Vec<DockerContainer> {
let mut out: Vec<DockerContainer> = lines::<RawContainer>(text)
.map(|r| {
+2 -23
Переглянути файл
@@ -1,8 +1,8 @@
//! Parsing of recorded `docker … --format '{{json .}}'` output.
use ide_docker::{
PS_FORMAT, parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images,
parse_networks, parse_volumes,
parse_container_stats, parse_container_top, parse_containers, parse_image_history, parse_images, parse_networks,
parse_volumes,
};
const PS: &str = include_str!("fixtures/ps.jsonl");
@@ -10,27 +10,6 @@ const IMAGES: &str = include_str!("fixtures/images.jsonl");
const VOLUMES: &str = include_str!("fixtures/volumes.jsonl");
const NETWORKS: &str = include_str!("fixtures/networks.jsonl");
/// Fills `{{json .Field}}` placeholders of a `--format` template from a `{{json .}}` line.
fn render(template: &str, line: &str) -> String {
let fields: serde_json::Map<String, serde_json::Value> = serde_json::from_str(line).unwrap();
let mut out = template.to_owned();
while let Some(start) = out.find("{{json .") {
let end = start + out[start..].find("}}").unwrap() + 2;
let key = &out[start + "{{json .".len()..end - 2];
let value = fields.get(key).unwrap_or_else(|| panic!("fixture lacks {key}"));
out.replace_range(start..end, &value.to_string());
}
out
}
#[test]
fn ps_format_carries_everything_the_parser_reads_but_size() {
assert!(!PS_FORMAT.contains("Size"), "Size makes the daemon compute container sizes");
let rendered: Vec<String> = PS.lines().filter(|l| l.starts_with('{')).map(|l| render(PS_FORMAT, l)).collect();
assert_eq!(rendered.len(), 2);
assert_eq!(parse_containers(&rendered.join("\n")), parse_containers(PS));
}
#[test]
fn containers_with_compose_labels() {
let c = parse_containers(PS);
+3 -33
Переглянути файл
@@ -26,8 +26,6 @@ pub enum Capability {
DatabaseSources,
VcsRead,
VcsWrite,
/// The Maven / Gradle dependency graph the IDE resolved.
BuildRead,
/// The plugin's own key-value store and data directory.
Storage,
/// The plugin's own secrets (kept in the client's OS keychain).
@@ -38,8 +36,6 @@ pub enum Capability {
InputEvents,
/// The system clipboard, from the plugin's web views.
Clipboard,
/// Read the clipboard from commands and view actions the user ran (API 1.11).
ClipboardRead,
/// HTTPS (and loopback HTTP) to one host (`*.example.com` matches subdomains).
Net(String),
/// Ask the user when the first request goes to an HTTPS (or loopback) host
@@ -59,9 +55,6 @@ pub enum Capability {
FsRead(String),
/// Write files outside the project under one path.
FsWrite(String),
/// Load the plugin's Java agent into the JVMs of Java run configurations. Never
/// declared: it comes from `[[contributes.javaAgents]]`.
JavaAgent,
}
/// How a grant is presented (plan 4.2).
@@ -79,9 +72,7 @@ pub enum Risk {
impl Capability {
pub fn risk(&self) -> Risk {
match self {
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
Risk::Low
}
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
Self::EditorWrite
| Self::DatabaseSources
| Self::VcsWrite
@@ -90,8 +81,7 @@ impl Capability {
| Self::NetHttp(_)
| Self::Secrets
| Self::InputEvents
| Self::Clipboard
| Self::ClipboardRead => Risk::Medium,
| Self::Clipboard => Risk::Medium,
// A trusted project's own files name the programs the IDE starts (its settings, its
// build scripts), so writing them is running code.
Self::ProjectWrite
@@ -100,8 +90,7 @@ impl Capability {
| Self::Process(_)
| Self::Lsp(_)
| Self::FsRead(_)
| Self::FsWrite(_)
| Self::JavaAgent => Risk::High,
| Self::FsWrite(_) => Risk::High,
}
}
@@ -122,7 +111,6 @@ impl Capability {
Self::IdeCommands => "Run any IDE action or other plugins' commands as if you chose them, including running programs, committing and pushing".into(),
Self::VcsRead => "Read version control state".into(),
Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
Self::BuildRead => "Read the project's resolved Maven and Gradle dependencies".into(),
Self::Storage => "Store its own data".into(),
Self::Secrets => "Store secrets in the system keychain".into(),
Self::Events => "Observe editor, filesystem and version control events".into(),
@@ -130,7 +118,6 @@ impl Capability {
Self::Clipboard => {
"Copy to the clipboard from its commands, and read and write it from its web views".into()
}
Self::ClipboardRead => "Read the clipboard's text and images when you run one of its commands".into(),
Self::Net(host) => format!("Connect to {host} (from the machine the project is on)"),
Self::NetAsk => {
"Ask to connect to a host that is not on the list the first time it tries; you allow or refuse each host, and can revoke the allowed ones"
@@ -148,7 +135,6 @@ impl Capability {
}
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
Self::JavaAgent => "Run code inside the Java applications you start".into(),
}
}
@@ -260,13 +246,11 @@ impl fmt::Display for Capability {
Self::DatabaseSources => f.write_str("database.sources"),
Self::VcsRead => f.write_str("vcs.read"),
Self::VcsWrite => f.write_str("vcs.write"),
Self::BuildRead => f.write_str("build.read"),
Self::Storage => f.write_str("storage"),
Self::Secrets => f.write_str("secrets"),
Self::Events => f.write_str("events"),
Self::InputEvents => f.write_str("events.input"),
Self::Clipboard => f.write_str("clipboard"),
Self::ClipboardRead => f.write_str("clipboard.read"),
Self::Net(h) => write!(f, "net:{h}"),
Self::NetAsk => f.write_str("net:ask"),
Self::NetHttp(h) => write!(f, "net.http:{h}"),
@@ -275,7 +259,6 @@ impl fmt::Display for Capability {
Self::Lsp(s) => write!(f, "lsp:{s}"),
Self::FsRead(p) => write!(f, "fs.read:{p}"),
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
Self::JavaAgent => f.write_str("java.agent"),
}
}
}
@@ -347,14 +330,11 @@ impl FromStr for Capability {
"database.sources" => Self::DatabaseSources,
"vcs.read" => Self::VcsRead,
"vcs.write" => Self::VcsWrite,
"build.read" => Self::BuildRead,
"storage" => Self::Storage,
"secrets" => Self::Secrets,
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"clipboard.read" => Self::ClipboardRead,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
}
@@ -403,8 +383,6 @@ mod tests {
"editor.write",
"project.write",
"vcs.write",
"build.read",
"clipboard.read",
"storage",
"secrets",
"events",
@@ -414,7 +392,6 @@ mod tests {
"process:cargo",
"lsp:phoxite",
"lsp:rust-analyzer",
"java.agent",
] {
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
}
@@ -446,17 +423,10 @@ mod tests {
assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
// Reading is its own grant: neither clipboard capability covers the other.
assert_eq!(Capability::ClipboardRead.risk(), Risk::Medium);
assert!(!Capability::Clipboard.covers(&Capability::ClipboardRead));
assert!(!Capability::ClipboardRead.covers(&Capability::Clipboard));
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
assert_eq!(Capability::JavaAgent.risk(), Risk::High);
assert!(!Capability::JavaAgent.auto_migrates());
}
/// A trusted project's files name programs the IDE starts by itself: the git and language
+2 -19
Переглянути файл
@@ -10,8 +10,6 @@
//! - `process:<program>` grants record the program's absolute path and file
//! hash at grant time. Calls use that path, never a `PATH` lookup, and fail
//! when the file changed (re-confirmation needed).
//! - `java.agent` grants record the agent jar's path and hash the same way;
//! a launch adds the agent only while the jar still has that hash.
use crate::capability::{Capability, Risk};
use serde::{Deserialize, Serialize};
@@ -269,7 +267,7 @@ impl Ledger {
if cap == &Capability::NetAsk {
grant.net_hosts.clear();
}
if let Capability::Process(_) | Capability::JavaAgent = cap {
if let Capability::Process(_) = cap {
grant.binaries.remove(&s);
for binaries in grant.project_binaries.values_mut() {
binaries.remove(&s);
@@ -292,7 +290,7 @@ impl Ledger {
self.grants.get_mut(subject).is_some_and(|g| g.net_hosts.remove(host))
}
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
/// Records the program approved for a `process:` grant.
pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
if let Some(grant) = self.grants.get_mut(subject) {
grant.binaries.insert(cap.to_string(), binary);
@@ -677,21 +675,6 @@ mod tests {
assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
}
#[test]
fn revoking_java_agent_forgets_its_jar() {
let mut l = Ledger::in_memory();
let r = req("1.0.0", "h", &[], &["java.agent"]);
let cap = Capability::JavaAgent;
let jar = BinaryGrant { path: "/plugins/p/agent.jar".into(), hash: "abc".into() };
l.confirm(&r, std::slice::from_ref(&cap), [(cap.to_string(), jar.clone())].into());
assert_eq!(l.pinned_binary(&r.subject, &cap), Some(jar.clone()));
l.set(&r.subject, &cap, false);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
// Granting again without a new hash does not bring the old one back.
l.set(&r.subject, &cap, true);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
}
#[test]
fn hashes_and_grouping() {
let tmp = tempfile::tempdir().unwrap();
+1 -36
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.11.0";
pub const ENGINE_VERSION: &str = "1.9.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -360,17 +360,6 @@ impl Manifest {
if matches!(cap, Capability::Lsp(_)) {
self.needs_api(&format!("capability `{cap}`"), 9)?;
}
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::ClipboardRead) {
self.needs_api(&format!("capability `{cap}`"), 11)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
);
}
}
if let Some(dark) = &self.icon_dark {
if self.icon.is_none() {
@@ -741,30 +730,6 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
}
#[test]
fn the_build_capability_needs_api_1_10() {
let caps = "[capabilities]\noptional = [\"build.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).contains("new in plugin API 1.10"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn the_clipboard_read_capability_needs_api_1_11() {
let caps = "[capabilities]\noptional = [\"clipboard.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("new in plugin API 1.11"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.11"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::ClipboardRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
let caps = format!("[capabilities]\n{list} = [\"java.agent\"]\n");
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("contributes.javaAgents"));
}
}
#[test]
fn parses_icons() {
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
-3
Переглянути файл
@@ -11,7 +11,6 @@ path = "src/bin/server.rs"
[dependencies]
encoding_rs.workspace = true
ide-command.workspace = true
ide-core.workspace = true
ide-mcp.workspace = true
futures.workspace = true
@@ -31,8 +30,6 @@ ide-vcs.workspace = true
ide-dap.workspace = true
ide-heap.workspace = true
ide-jvm-attach.workspace = true
ide-jvm-inspect.workspace = true
ide-streams.workspace = true
ide-build.workspace = true
ide-analysis.workspace = true
ide-coverage.workspace = true
+1 -2
Переглянути файл
@@ -1,7 +1,6 @@
//! `openidea-server --stdio`: the IDE backend for remote development, serving
//! one desktop client over stdin / stdout (started by the client over SSH).
use ide_host::catalogue::TrustClass;
use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
use ide_host::plugins::remote_host::RemotePlugins;
use ide_host::rpc::{self, Dispatcher};
@@ -103,7 +102,7 @@ async fn run(base: PathBuf) -> i32 {
if let Some(plugins) = &plugins {
plugins.register(&mut dispatcher);
}
dispatcher.add(SYNC_COMMAND, TrustClass::Trusted, move |c| {
dispatcher.add(SYNC_COMMAND, move |c| {
let remote = plugin_languages.clone();
async move {
let report = remote.sync(c.arg("languages")?);
-40
Переглянути файл
@@ -1,40 +0,0 @@
//! What every command declares: its trust class, where it runs, and how Tauri runs it.
//! `#[ide_command::command]` and `#[ide_command::desktop_command]` give each command a
//! [`Command`].
/// Where a command may run, from the trust decision of the window's project.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TrustClass {
/// Everywhere, including Restricted Mode.
Always,
/// With no project open, or in a trusted project.
OutsideRestricted,
/// Only in a trusted project.
Trusted,
}
/// Which backend runs a command for a remote window.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Placement {
Desktop,
ProjectHost,
}
/// How Tauri runs the command: on the invoking thread, as a future, or on its thread pool.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Mode {
Sync,
Async,
Spawn,
}
/// One command's declaration.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Command {
pub name: &'static str,
pub trust: TrustClass,
pub placement: Placement,
/// In `bindings.ts`; a command registered outside tauri-specta isn't.
pub bindings: bool,
pub mode: Mode,
}
-426
Переглянути файл
@@ -1,426 +0,0 @@
//! The project's direnv environment: when the project root has an `.envrc`, `direnv export
//! json` runs there and every child started in the project gets what it exports
//! ([`ide_core::project_env`]): terminals, runs, language servers (which wait for it), build
//! tools and debuggers, locally and on a remote host alike. An `.envrc` with `use flake`
//! loads a Nix flake's devshell this way.
//!
//! `.envrc` is project code: it runs in trusted projects only, and only once the user
//! allowed it with `direnv allow`, which the IDE never does for them.
use ide_core::event::DirenvStatus;
use ide_core::{CancellationToken, IdeEvent, SharedSink, TaskId};
use std::collections::BTreeMap;
use std::ffi::OsString;
use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::mpsc::RecvTimeoutError;
use std::time::{Duration, Instant};
pub(crate) const ENVRC: &str = ".envrc";
/// Files in the project root whose change offers a reload: the `.envrc` and the flake
/// `use flake` evaluates.
const WATCHED: [&str; 3] = [ENVRC, "flake.nix", "flake.lock"];
/// A cold `use flake` builds or downloads the devshell: minutes, not seconds.
pub(crate) const TIMEOUT: Duration = Duration::from_secs(10 * 60);
/// Output lines kept for a failure's notification.
const TAIL_LINES: usize = 12;
pub(crate) type Changes = Vec<(OsString, Option<OsString>)>;
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Failure {
/// The user hasn't allowed this `.envrc` (`direnv allow`).
Blocked,
Failed(String),
Cancelled,
}
pub(crate) fn has_envrc(root: &Path) -> bool {
root.join(ENVRC).is_file()
}
/// `direnv` on the IDE's search path.
pub(crate) fn program() -> Option<PathBuf> {
ide_core::process::find_executable("direnv", &ide_core::tool_path::search_path())
}
/// The watched file among `paths` (changed or removed below `root`), when the project has an
/// `.envrc` or just lost it: what a reload would pick up.
pub(crate) fn reload_offer<'a>(root: &Path, paths: impl IntoIterator<Item = &'a PathBuf>) -> Option<String> {
let file = paths
.into_iter()
.filter(|p| p.parent() == Some(root))
.filter_map(|p| p.file_name()?.to_str())
.find(|name| WATCHED.contains(name))?;
(file == ENVRC || has_envrc(root)).then(|| file.to_owned())
}
/// Runs `program export json` in `root` from the environment children outside any project
/// get (not the project's last one: a reload must not see its own result), reporting
/// direnv's progress lines to `on_line`. Gives up after `timeout` or once `cancel` fires,
/// stopping what direnv started (`nix`) too.
pub(crate) fn export(
program: &Path,
root: &Path,
timeout: Duration,
cancel: &CancellationToken,
on_line: &dyn Fn(&str),
) -> Result<Changes, Failure> {
let mut cmd = Command::new(program);
ide_core::process::prepare(ide_core::process::own_group(&mut cmd));
let mut child = cmd
.args(["export", "json"])
.current_dir(root)
.env_clear()
.envs(ide_core::process::host_vars())
.envs(ide_core::process::shell_env())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| Failure::Failed(format!("cannot start {}: {e}", program.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let out = std::thread::spawn(move || {
let mut buf = Vec::new();
stdout.read_to_end(&mut buf).map(|_| buf)
});
let (tx, rx) = std::sync::mpsc::channel::<String>();
let stderr = child.stderr.take().expect("piped");
std::thread::spawn(move || {
for line in BufReader::new(stderr).split(b'\n').map_while(Result::ok) {
let line = ide_core::output_encoding::decode_tool_output(&line).trim_end_matches('\r').to_owned();
if tx.send(line).is_err() {
break;
}
}
});
let deadline = Instant::now() + timeout;
let mut tail: Vec<String> = Vec::new();
let mut keep = |line: String| {
on_line(&line);
tail.push(line);
let excess = tail.len().saturating_sub(TAIL_LINES);
tail.drain(..excess);
};
loop {
if cancel.is_cancelled() {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Cancelled);
}
if Instant::now() > deadline {
ide_core::process::kill_tree(&mut child);
return Err(Failure::Failed(format!(
"direnv did not finish within {} minutes.\n\n{}",
timeout.as_secs() / 60,
tail.join("\n")
)));
}
match rx.recv_timeout(Duration::from_millis(50)) {
Ok(line) => keep(line),
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
}
let status = child.wait().map_err(|e| Failure::Failed(e.to_string()))?;
let stdout = out.join().ok().and_then(Result::ok).unwrap_or_default();
if tail.iter().any(|l| l.contains("is blocked") || l.contains("is not allowed")) {
return Err(Failure::Blocked);
}
if !status.success() {
let tail = tail.join("\n");
return Err(Failure::Failed(if tail.is_empty() { format!("direnv exited with {status}") } else { tail }));
}
parse(&stdout).map_err(Failure::Failed)
}
/// `direnv export json`'s output: the variables to set, `null` for those to unset; nothing
/// when there is nothing to change.
fn parse(stdout: &[u8]) -> Result<Changes, String> {
if stdout.iter().all(u8::is_ascii_whitespace) {
return Ok(Changes::new());
}
let vars: BTreeMap<String, Option<String>> =
serde_json::from_slice(stdout).map_err(|e| format!("unexpected output from direnv: {e}"))?;
Ok(vars.into_iter().map(|(k, v)| (k.into(), v.map(Into::into))).collect())
}
/// Loads `root`'s environment with `program` (`None`: direnv isn't installed) into
/// [`ide_core::project_env`], as a cancellable background task; what went wrong is a
/// [`IdeEvent::Direnv`]. `current` says whether this load still owns `root` (not closed or
/// superseded by a newer one meanwhile) and is checked again before anything is applied.
pub(crate) fn load(
root: &Path,
program: Option<&Path>,
sink: &SharedSink,
cancel: &CancellationToken,
timeout: Duration,
hint_missing: bool,
current: &dyn Fn(&dyn Fn()),
) {
let report = |status: DirenvStatus| sink.emit(IdeEvent::Direnv { root: root.to_path_buf().into(), status });
let Some(program) = program else {
current(&|| ide_core::project_env::settle(root));
if hint_missing {
report(DirenvStatus::NotInstalled);
}
return;
};
let task = TaskId::next();
let _cancel_handle = ide_core::task::on_cancel(task, {
let cancel = cancel.clone();
move || cancel.cancel()
});
let progress = |message: Option<String>, done: bool| {
sink.emit(IdeEvent::Task {
id: task,
title: "Loading the direnv environment".into(),
message,
fraction: None,
done,
cancellable: !done,
});
};
progress(Some(format!("{} export json", program.display())), false);
let result = export(program, root, timeout, cancel, &|line| progress(Some(line.to_owned()), false));
progress(None, true);
match result {
Ok(changes) => {
tracing::info!("direnv: {} variables for {}", changes.len(), root.display());
current(&|| ide_core::project_env::set(root, changes.clone()));
}
Err(Failure::Blocked) => {
// As in a shell: a blocked `.envrc` isn't loaded.
current(&|| ide_core::project_env::set(root, Changes::new()));
report(DirenvStatus::Blocked);
}
Err(Failure::Failed(message)) => {
tracing::warn!("direnv in {}: {message}", root.display());
current(&|| ide_core::project_env::settle(root));
report(DirenvStatus::Failed { message });
}
// Closed or superseded (that one settles), or stopped from the task list.
Err(Failure::Cancelled) => current(&|| ide_core::project_env::settle(root)),
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use ide_core::EventSink;
use parking_lot::Mutex;
use std::os::unix::fs::PermissionsExt;
use std::sync::Arc;
/// A stand-in `direnv`: checks its arguments, then prints `stderr` and `out.json` of the
/// folder it runs in and exits with `code`, or blocks like direnv on an `.envrc` not allowed.
fn fake_direnv(dir: &Path) -> PathBuf {
let program = dir.join("direnv");
std::fs::write(
&program,
r#"#!/bin/sh
[ "$1 $2" = "export json" ] || { echo "direnv: unexpected arguments $*" >&2; exit 2; }
echo "direnv: loading $PWD/.envrc" >&2
[ -f slow ] && sleep 30
[ -f blocked ] && { echo "direnv: error $PWD/.envrc is blocked. Run \`direnv allow\` to approve its content" >&2; exit 1; }
[ -f stderr ] && cat stderr >&2
[ -f out.json ] && cat out.json
echo "direnv: export +NIX_DEV" >&2
exit "$(cat code 2>/dev/null || echo 0)"
"#,
)
.unwrap();
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
program
}
fn project() -> (tempfile::TempDir, PathBuf, PathBuf) {
let tmp = tempfile::tempdir().unwrap();
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
std::fs::create_dir(&root).unwrap();
std::fs::write(root.join(ENVRC), "use flake\n").unwrap();
let program = fake_direnv(tmp.path());
(tmp, root, program)
}
fn run(program: &Path, root: &Path) -> (Result<Changes, Failure>, Vec<String>) {
let lines = Mutex::new(Vec::new());
let result = export(program, root, Duration::from_secs(20), &CancellationToken::new(), &|l| {
lines.lock().push(l.to_owned())
});
(result, lines.into_inner())
}
fn change(k: &str, v: Option<&str>) -> (OsString, Option<OsString>) {
(k.into(), v.map(Into::into))
}
#[test]
fn exported_variables_are_set_and_unset() {
let (_tmp, root, program) = project();
std::fs::write(
root.join("out.json"),
r#"{"PATH":"/nix/store/abc-devshell/bin:/usr/bin","IN_NIX_SHELL":"impure","OLD":null}"#,
)
.unwrap();
let (result, lines) = run(&program, &root);
assert_eq!(
result.unwrap(),
[
change("IN_NIX_SHELL", Some("impure")),
change("OLD", None),
change("PATH", Some("/nix/store/abc-devshell/bin:/usr/bin")),
]
);
assert_eq!(lines, [format!("direnv: loading {}/.envrc", root.display()), "direnv: export +NIX_DEV".into()]);
}
#[test]
fn nothing_to_export_changes_nothing() {
let (_tmp, root, program) = project();
assert_eq!(run(&program, &root).0, Ok(Changes::new()));
}
#[test]
fn a_blocked_envrc_is_reported_as_such() {
let (_tmp, root, program) = project();
std::fs::write(root.join("blocked"), "").unwrap();
assert_eq!(run(&program, &root).0, Err(Failure::Blocked));
}
#[test]
fn a_failure_reports_the_end_of_the_output() {
let (_tmp, root, program) = project();
std::fs::write(root.join("stderr"), "error: flake 'path:/p' does not provide attribute 'devShells'\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.contains("does not provide attribute 'devShells'"), "{message}");
std::fs::remove_file(root.join("code")).unwrap();
std::fs::write(root.join("out.json"), "not json").unwrap();
let Err(Failure::Failed(message)) = run(&program, &root).0 else { panic!("a failure") };
assert!(message.starts_with("unexpected output from direnv"), "{message}");
}
#[test]
fn a_slow_direnv_times_out_or_is_cancelled() {
let (_tmp, root, program) = project();
std::fs::write(root.join("slow"), "").unwrap();
let started = Instant::now();
let result = export(&program, &root, Duration::from_secs(2), &CancellationToken::new(), &|_| {});
let Err(Failure::Failed(message)) = result else { panic!("a timeout") };
assert!(message.starts_with("direnv did not finish within"), "{message}");
assert!(message.contains("direnv: loading"), "{message}");
let cancel = CancellationToken::new();
let c = cancel.clone();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(200));
c.cancel();
});
assert_eq!(export(&program, &root, Duration::from_secs(60), &cancel, &|_| {}), Err(Failure::Cancelled));
assert!(started.elapsed() < Duration::from_secs(20));
}
#[test]
fn missing_program_is_a_start_failure() {
let (_tmp, root, _) = project();
let Err(Failure::Failed(message)) = run(Path::new("/openidea-no-such/direnv"), &root).0 else { panic!() };
assert!(message.starts_with("cannot start"), "{message}");
}
#[derive(Default)]
struct Events(Mutex<Vec<IdeEvent>>);
impl EventSink for Events {
fn emit(&self, e: IdeEvent) {
self.0.lock().push(e);
}
}
fn statuses(events: &Events) -> Vec<DirenvStatus> {
events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Direnv { status, .. } => Some(status.clone()),
_ => None,
})
.collect()
}
fn load_with(root: &Path, program: Option<&Path>, hint: bool) -> Arc<Events> {
let events = Arc::new(Events::default());
let sink: SharedSink = events.clone();
ide_core::project_env::begin_loading(root);
load(root, program, &sink, &CancellationToken::new(), Duration::from_secs(20), hint, &|apply| apply());
events
}
#[test]
fn children_in_the_project_get_what_direnv_exported() {
let (_tmp, root, program) = project();
std::fs::write(root.join("out.json"), r#"{"OPENIDEA_TEST_DEVSHELL":"1"}"#).unwrap();
let events = load_with(&root, Some(&program), true);
assert!(statuses(&events).is_empty());
assert!(!ide_core::project_env::is_loading(&root));
let mut cmd = Command::new("true");
cmd.current_dir(root.join("src"));
ide_core::process::host_env(&mut cmd);
assert!(cmd.get_envs().any(|(k, v)| k == "OPENIDEA_TEST_DEVSHELL" && v == Some("1".as_ref())));
// A task shows the progress, and ends.
let tasks: Vec<_> = events
.0
.lock()
.iter()
.filter_map(|e| match e {
IdeEvent::Task { message, done, .. } => Some((message.clone(), *done)),
_ => None,
})
.collect();
assert!(tasks.iter().any(|(m, _)| m.as_deref() == Some("direnv: export +NIX_DEV")), "{tasks:?}");
assert_eq!(tasks.last(), Some(&(None, true)));
// Blocked after an edit: the environment goes, as in a shell.
std::fs::write(root.join("blocked"), "").unwrap();
let events = load_with(&root, Some(&program), true);
assert_eq!(statuses(&events), [DirenvStatus::Blocked]);
assert!(ide_core::project_env::for_dir(&root).is_empty());
// A failure keeps the last environment and says why.
std::fs::remove_file(root.join("blocked")).unwrap();
load_with(&root, Some(&program), true);
std::fs::write(root.join("stderr"), "error: syntax error in flake.nix\n").unwrap();
std::fs::write(root.join("code"), "1").unwrap();
let events = load_with(&root, Some(&program), true);
let [DirenvStatus::Failed { message }] = &statuses(&events)[..] else { panic!("{:?}", statuses(&events)) };
assert!(message.contains("syntax error in flake.nix"), "{message}");
assert!(!ide_core::project_env::for_dir(&root).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn direnv_not_installed_is_hinted_once_and_does_not_block() {
let (_tmp, root, _) = project();
let events = load_with(&root, None, true);
assert_eq!(statuses(&events), [DirenvStatus::NotInstalled]);
assert!(!ide_core::project_env::is_loading(&root), "language servers start anyway");
assert!(statuses(&load_with(&root, None, false)).is_empty());
ide_core::project_env::remove(&root);
}
#[test]
fn changes_to_the_envrc_or_flake_offer_a_reload() {
let (_tmp, root, _) = project();
let paths = |names: &[&str]| names.iter().map(|n| root.join(n)).collect::<Vec<_>>();
assert_eq!(reload_offer(&root, &paths(&["src/main.rs", "flake.lock"])), Some("flake.lock".into()));
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()));
assert_eq!(reload_offer(&root, &paths(&["sub/flake.nix", "src/main.rs"])), None, "the project root's only");
std::fs::remove_file(root.join(ENVRC)).unwrap();
assert_eq!(reload_offer(&root, &paths(&["flake.nix"])), None, "no .envrc: nothing loads the flake");
assert_eq!(reload_offer(&root, &paths(&[".envrc"])), Some(".envrc".into()), "removed: reload unloads");
}
}
+11 -92
Переглянути файл
@@ -1,11 +1,9 @@
//! The environment child processes get beyond this process's own: the login shell's as
//! re-read by Reload Environment, (remote server) the project's `devcontainer.json`
//! `remoteEnv`, plus its `postStartCommand` once per server start, and each trusted
//! project's direnv `.envrc` ([`crate::direnv`]).
//! re-read by Reload Environment, and (remote server) the project's
//! `devcontainer.json` `remoteEnv`, plus its `postStartCommand` once per server start.
//!
//! The first two reach every child through `ide_core::process::set_env_overlay`, a project's
//! direnv environment the children started inside it (`ide_core::project_env`): terminals,
//! runs, language servers, debug adapters, build tools and git all spawn through
//! Both reach every child through `ide_core::process::set_env_overlay`: terminals, runs,
//! language servers, debug adapters, build tools and git all spawn through
//! `ide_core::process::prepare` / `host_env`.
use ide_core::event::NotifyLevel;
@@ -20,7 +18,6 @@ use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::Duration;
type Changes = Vec<(OsString, Option<OsString>)>;
@@ -54,87 +51,18 @@ struct State {
post_commands: std::collections::HashMap<PathBuf, CancellationToken>,
}
/// Project roots whose direnv environment is loaded or loading, with the load that owns
/// each (a generation) and what stops it.
type DirenvLoads = Arc<Mutex<std::collections::HashMap<PathBuf, (u64, CancellationToken)>>>;
pub struct Environment {
/// Whether the open project's `devcontainer.json` applies (the remote server: one project per process).
project_env: bool,
data_dir: PathBuf,
state: Mutex<State>,
/// Stops running `postStartCommand`s and direnv loads when the host shuts down.
/// Stops running `postStartCommand`s when the host shuts down.
cancel: CancellationToken,
direnv: DirenvLoads,
/// "direnv is not installed" is said once per process.
direnv_hinted: AtomicBool,
}
impl Environment {
pub(crate) fn new(project_env: bool, data_dir: PathBuf) -> Self {
Self {
project_env,
data_dir,
state: Mutex::default(),
cancel: CancellationToken::new(),
direnv: DirenvLoads::default(),
direnv_hinted: AtomicBool::new(false),
}
}
/// A trusted project at `root` opened or became trusted: loads its direnv environment in
/// the background, unless another window of it already did. Its language servers wait.
pub(crate) fn direnv_opened(&self, root: &Path, sink: &SharedSink) {
if !self.direnv.lock().contains_key(root) {
self.load_direnv(root, sink, true);
}
}
/// The project at `root` closed in its last window, or is no longer trusted.
pub(crate) fn direnv_closed(&self, root: &Path) {
if let Some((_, cancel)) = self.direnv.lock().remove(root) {
cancel.cancel();
}
ide_core::project_env::remove(root);
}
/// (Re)loads `root`'s direnv environment, replacing a load still running; on this thread
/// unless `background`. Without an `.envrc` the project has none.
fn load_direnv(&self, root: &Path, sink: &SharedSink, background: bool) {
static GENERATION: AtomicU64 = AtomicU64::new(0);
let generation = GENERATION.fetch_add(1, Ordering::Relaxed);
let cancel = self.cancel.child_token();
{
let mut loads = self.direnv.lock();
if let Some((_, previous)) = loads.insert(root.to_path_buf(), (generation, cancel.clone())) {
previous.cancel();
}
if !crate::direnv::has_envrc(root) {
ide_core::project_env::remove(root);
return;
}
// Before this returns: a language server starting next waits for it.
ide_core::project_env::begin_loading(root);
}
let program = crate::direnv::program();
let hint = program.is_none() && !self.direnv_hinted.swap(true, Ordering::AcqRel);
let (loads, dir, sink) = (self.direnv.clone(), root.to_path_buf(), sink.clone());
let run = move || {
let current = |apply: &dyn Fn()| {
let loads = loads.lock();
if loads.get(&dir).is_some_and(|(g, _)| *g == generation) {
apply();
}
};
crate::direnv::load(&dir, program.as_deref(), &sink, &cancel, crate::direnv::TIMEOUT, hint, &current);
};
if !background {
run();
} else if let Err(e) = std::thread::Builder::new().name("openidea-direnv".into()).spawn(run) {
tracing::warn!("direnv: {e}");
// Language servers must not wait for a load that never runs.
ide_core::project_env::settle(root);
}
Self { project_env, data_dir, state: Mutex::default(), cancel: CancellationToken::new() }
}
pub(crate) fn shutdown(&self) {
@@ -190,17 +118,11 @@ impl Environment {
ide_core::process::set_env_overlay(merge(&state.login, &state.project));
}
/// Reload Environment: reads the login shell again, re-applies the project's `remoteEnv`
/// and loads its direnv environment again (`root`, a trusted project). Blocking (it runs
/// the shell and direnv); children already running keep their environment.
/// Reload Environment: reads the login shell again and re-applies the project's
/// `remoteEnv` (`root`). Blocking (it runs the shell); children already running keep
/// their environment.
pub fn reload(&self, root: Option<&Path>, sink: &SharedSink) -> IdeResult<EnvReloaded> {
let vars = || -> Vec<_> {
match root {
Some(root) => ide_core::process::host_vars_in(root).collect(),
None => ide_core::process::host_vars().collect(),
}
};
let before = vars();
let before: Vec<_> = ide_core::process::host_vars().collect();
let fresh = crate::shell_env::read_login_env_now().map_err(IdeError::unavailable)?;
let shell_read = fresh.is_some();
if let Some(fresh) = fresh {
@@ -224,10 +146,7 @@ impl Environment {
None
}
};
if let Some(root) = root {
self.load_direnv(root, sink, false);
}
let after = vars();
let after: Vec<_> = ide_core::process::host_vars().collect();
Ok(EnvReloaded { changed: changed_names(&before, &after), devcontainer, shell_read })
}
+1 -15
Переглянути файл
@@ -4,10 +4,8 @@
//! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
pub mod agent_secrets;
pub mod catalogue;
pub mod data_dirs;
pub mod diagnostics_store;
mod direnv;
pub mod environment;
mod formatter;
mod java_runtime;
@@ -25,7 +23,7 @@ pub mod rpc;
pub mod shell_env;
pub mod trust;
pub use project::{Project, apply_git_executable, history_retention};
pub use project::{Project, apply_git_executable, apply_workspace_edit, history_retention};
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId, SharedSink};
use ide_language::{LanguageRegistry, Syntax};
@@ -93,8 +91,6 @@ pub struct Host {
pub ssh: Arc<ide_ssh::SshManager>,
/// SFTP deployment, remote file editing and runs on run targets.
pub remote: Arc<ide_remote::RemoteService>,
/// Tunnels of Docker connections made through an SSH configuration.
pub docker_tunnels: ops::docker::DockerTunnels,
/// What child processes get beyond this process's environment (Reload Environment, `remoteEnv`).
pub environment: environment::Environment,
/// The built-in web server (Open In › Browser, the editor's browser bar). On a remote host the
@@ -165,7 +161,6 @@ impl Host {
agent_secrets: Arc::new(agent_secrets::AgentSecrets::new(&data_dir)),
remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
ssh,
docker_tunnels: Default::default(),
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
web: ide_web::WebServer::new(),
global_settings,
@@ -196,12 +191,6 @@ impl Host {
};
host.apply_proxy();
host.apply_added_jdks();
// Before any project starts jdtls; the deleting itself can take a while.
let unused =
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
if !unused.is_empty() {
std::thread::spawn(move || ide_sdk::jdtls_workspaces::remove(unused));
}
ops::agent::move_user_mcp_values(&host);
host
}
@@ -319,9 +308,6 @@ impl Host {
}
if !project.light {
self.environment.project_closed();
if self.windows_for_root(&project.root).is_empty() {
self.environment.direnv_closed(&project.root);
}
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.stop();
+3 -3
Переглянути файл
@@ -873,15 +873,15 @@ async fn occurrences(
let host = call.host();
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let emit = {
let emit: crate::ops::Emit<SearchEvent> = {
let files = files.clone();
crate::ops::Channel::new(move |event: SearchEvent| {
Arc::new(move |event| {
if let SearchEvent::File { file } = event {
files.lock().push(file);
}
})
};
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
tokio::pin!(search);
tokio::select! {
r = &mut search => r?,
+1 -1
Переглянути файл
@@ -57,7 +57,7 @@ The maximum accepted limit is 5000 lines.",
probe.size
)));
}
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
Ok(Output::text(render_slice(&text, offset as usize, limit as usize, window)?))
},
)
+2 -2
Переглянути файл
@@ -37,7 +37,7 @@ Returns each request's 0-based `index`, optional `name`, `method`, URL as writte
Use `http_run_request` with the same `path` and an `index` to send one.",
|call| async move {
let path = resolve_http_file(&call, &call.str("path")?).await?;
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
let requests: Vec<_> = ide_http::parse::requests(&text)
.into_iter()
.map(|b| {
@@ -139,7 +139,7 @@ The `url` field in the result is as written in the file (unsubstituted); transpo
}
let index = index as u32;
let env = call.opt_str("env")?;
let text = crate::ops::fs::fs_read_text(&call.host(), call.window(), path.clone()).await?;
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
let blocks = ide_http::parse::requests(&text);
let block =
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
+2 -5
Переглянути файл
@@ -9,7 +9,7 @@ pub use requests::Requests;
mod files;
mod http;
mod page;
pub mod reports;
mod reports;
mod scope;
mod search;
mod symbols;
@@ -19,9 +19,7 @@ mod util;
use crate::Host;
use ide_core::{CancellationToken, IdeError};
use ide_mcp::{ToolCallError, ToolRegistry};
pub use reports::{
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
};
pub use reports::{FileProblems, FocusedEditor, Reports};
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -40,7 +38,6 @@ fn tools() -> Vec<tool::Tool> {
tools.push(check::check_files());
tools.push(symbols::get_symbol_info());
tools.push(symbols::find_references());
tools.push(symbols::get_call_hierarchy());
tools.extend(edit::tools());
tools.extend(run::tools());
tools.extend(vcs::tools());
-39
Переглянути файл
@@ -1,5 +1,4 @@
//! Window-owned snapshots. A project close drops every report from that window.
use ide_command::command;
use ide_core::{Diagnostic, IpcPath, Range};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
@@ -135,37 +134,6 @@ impl Reports {
}
}
#[command(trust = trusted)]
pub fn mcp_set_open_editors(host: &crate::Host, window: &str, paths: Vec<IpcPath>) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_open_editors(window, paths.into_iter().map(PathBuf::from).collect());
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_set_focused_editor(
host: &crate::Host,
window: &str,
editor: Option<FocusedEditor>,
focused: bool,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.set_focused_editor(window, editor, focused);
Ok(())
}
#[command(trust = trusted)]
pub fn mcp_report_problems(
host: &crate::Host,
window: &str,
reset: bool,
files: Vec<FileProblems>,
) -> ide_core::IdeResult<()> {
host.project(window)?;
host.mcp_reports.report_problems(window, reset, files);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
@@ -186,10 +154,3 @@ mod tests {
assert_eq!(windows, ["a", "b", "never", "c"]);
}
}
ide_command::domain!(
mcp_reports:
mcp_report_problems,
mcp_set_focused_editor,
mcp_set_open_editors,
);
+4 -4
Переглянути файл
@@ -418,10 +418,10 @@ input). Terminal keys (arrows, Escape, Backspace, Ctrl+Z…) are refused. To ans
host.processes.write_stdin(id, &std::mem::take(&mut data))?;
}
if key == Key::EndOfInput {
crate::ops::run::run_close_stdin(&host, id)?;
crate::ops::run::close_stdin(&host, id)?;
} else {
run.agent_stopping();
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
break;
}
}
@@ -455,10 +455,10 @@ keeps `stopping`: call again with `force`. The tab stays open with its output."
let deadline = deadline(&call, STOP_TIMEOUT_MS)?;
let host = call.host();
run.agent_stopping();
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
if force {
// A second Stop kills the tree.
crate::ops::run::run_stop(&host, &run.window(), id)?;
crate::ops::run::stop(&host, &run.window(), id)?;
}
let end = run.wait(deadline, None, run.log_len(), &call.cancel).await?;
let mut extra = Map::new();
+6 -6
Переглянути файл
@@ -283,7 +283,7 @@ fn run_exit(host: &crate::Host, id: RunId) -> Option<Option<i32>> {
match host.processes.exit_code(id) {
Ok(exit) => exit,
// Remote (SSH) runs, or a finished run already forgotten: the run list knows whether it runs.
Err(_) => match crate::ops::run::run_list(host).into_iter().find(|r| r.id == id) {
Err(_) => match crate::ops::run::list(host).into_iter().find(|r| r.id == id) {
Some(r) if r.running => None,
_ => Some(None),
},
@@ -304,7 +304,7 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
tokio::select! {
_ = tokio::time::sleep(Duration::from_millis(50)) => {}
_ = call.cancel.cancelled() => {
let _ = crate::ops::run::run_stop(&host, call.window(), id);
let _ = crate::ops::run::stop(&host, call.window(), id);
return Err(IdeError::cancelled());
}
}
@@ -313,9 +313,9 @@ async fn wait_exit(call: &Call, id: RunId, deadline: Option<Instant>) -> IdeResu
/// An output callback that skips the IDE's own lines (`Process finished…`), as JetBrains
/// skips `ProcessOutputType.SYSTEM`.
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Channel<OutputChunk> {
fn process_output(mut f: impl FnMut(&str) + Send + 'static) -> crate::ops::Emit<OutputChunk> {
let f = Mutex::new(move |t: &str| f(t));
crate::ops::Channel::new(move |chunk: OutputChunk| match &chunk {
Arc::new(move |chunk: OutputChunk| match &chunk {
OutputChunk::Stdout { text } | OutputChunk::Stderr { text } => (f.lock())(text),
OutputChunk::System { .. } => {}
})
@@ -356,7 +356,7 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
t.drain(..cut);
}
});
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
let info = crate::ops::run::start(&call.host(), call.window(), config, emit).await?;
let exit = wait_exit(call, info.id, None).await?.flatten();
if exit == Some(0) {
return Ok(true);
@@ -612,7 +612,7 @@ one by one",
let output_path = collector.lock().path.clone();
let sink = collector.clone();
let emit = process_output(move |text| sink.lock().append(text));
let info = match crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await {
let info = match crate::ops::run::start(&call.host(), call.window(), config, emit).await {
Ok(info) => info,
Err(e) => {
let _ = std::fs::remove_file(&output_path);
+2 -7
Переглянути файл
@@ -25,17 +25,12 @@ impl Scope {
} else {
call.root().join(given)
});
let roots: Vec<PathBuf> =
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
if !ide_vfs::content_path_allowed(&path, &roots) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
if !roots.iter().any(|root| path.starts_with(root)) {
let roots = std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots());
if !roots.into_iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
+17 -27
Переглянути файл
@@ -280,7 +280,7 @@ fn context(call: &Call) -> IdeResult<(u32, u32)> {
/// `line`, or when longer than [`MAX_LINE_TEXT`] UTF-16 units, the part from [`SNIPPET_AROUND`]
/// units before 0-based UTF-16 column `start` to as many after `end`, with `…` where it was cut.
pub(super) fn snippet(line: &str, start: usize, end: usize) -> String {
fn snippet(line: &str, start: usize, end: usize) -> String {
let units: usize = line.chars().map(char::len_utf16).sum();
if units <= MAX_LINE_TEXT {
return line.to_owned();
@@ -317,7 +317,7 @@ async fn fill_lines(
for item in items {
let (Some(path), Some(line)) = (absolute(item), item.start_line) else { continue };
if current.as_ref().is_none_or(|(p, _)| p != &path) {
let text = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await.ok();
let text = crate::ops::fs::read_text(&host, call.window(), path.clone()).await.ok();
let lines = text.map(|t| t.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l).to_owned()).collect());
current = Some((path, lines));
}
@@ -595,7 +595,7 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
// such lines are matched again in the file's whole text.
let long = |m: &ide_search::LineMatch| m.text_offset > 0 || m.text.encode_utf16().count() + 1 >= LINE_WINDOW;
let whole = if file.matches.iter().any(long) {
crate::ops::fs::fs_read_text(&host, call.window(), file.path.0.clone())
crate::ops::fs::read_text(&host, call.window(), file.path.0.clone())
.await
.ok()
.and_then(|text| Some((ide_search::match_ranges(&text, &query).ok()?, text)))
@@ -678,7 +678,7 @@ async fn extend_spanning(call: &Call, query: &SearchQuery, hits: &mut [TextHit],
let mut current: Option<FileText> = None;
for (i, path) in spanning {
if current.as_ref().is_none_or(|(p, ..)| p != &path) {
let Ok(text) = crate::ops::fs::fs_read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(text) = crate::ops::fs::read_text(&host, call.window(), path.clone()).await else { continue };
let Ok(ranges) = ide_search::match_ranges(&text, query) else { continue };
let starts = std::iter::once(0).chain(text.match_indices('\n').map(|(i, _)| i + 1)).collect();
current = Some((path, text, starts, ranges));
@@ -714,14 +714,14 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
let request = crate::mcp::tool::request_id();
let files = Arc::new(Mutex::new(Vec::new()));
let done = Arc::new(Mutex::new(None));
let emit = {
let emit: crate::ops::Emit<SearchEvent> = {
let (files, done) = (files.clone(), done.clone());
crate::ops::Channel::new(move |event: SearchEvent| match event {
Arc::new(move |event| match event {
SearchEvent::File { file } => files.lock().push(file),
SearchEvent::Done { summary } => *done.lock() = Some(summary),
})
};
let search = crate::ops::search::search_start(&host, call.window(), request, query, emit);
let search = crate::ops::search::start(&host, call.window(), request, query, emit);
tokio::pin!(search);
let mut timed_out = false;
tokio::select! {
@@ -822,7 +822,7 @@ impl Walk {
/// Collects matching files under `dir` (inside the walked root `base`) depth first in
/// name order; true when it stopped early: more than `limit` match or the time ran out.
fn dir(&self, dir: &Path, base: &Path, found: &mut Vec<String>) -> bool {
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::fs_read_dir(
let Ok(mut entries) = tokio::runtime::Handle::current().block_on(crate::ops::fs::read_dir(
&self.host,
&self.window,
dir.to_path_buf(),
@@ -883,20 +883,14 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let host = call.host();
let project = call.project().clone();
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let pool = if scope.is_all() && dir.dir().is_none() {
limit + 1
} else {
((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL)
};
let found = {
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
host.blocking(move || {
Ok(match dir {
// Filtered in the index: a pool cut before the filter could miss every match.
Some(dir) => project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
})
})
.await?
let (project, q) = (project.clone(), q.clone());
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
};
let mut items: Vec<SearchItem> = found
.into_iter()
@@ -916,14 +910,10 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
timed_out = out_of_time;
let mut roots = project.content_roots();
roots.extend(crate::mcp::tool::attached_projects(call.root()));
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
// Project files obey `scope` and `paths`; library symbols are what was asked for.
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
continue;
}
+22 -422
Переглянути файл
@@ -1,13 +1,10 @@
//! Quick Documentation through the project's language services.
use super::tool::{Call, Output, Param, ParamType, Tool};
use ide_core::error::ErrorKind;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Pos, Range, RequestId, SymbolKind};
use ide_lsp::types::{CallHierarchy, GotoKind, HierarchyDirection, HierarchyItem, ReferencesIncomplete};
use ide_core::{IdeError, IdeResult, Pos, Range};
use ide_lsp::types::GotoKind;
use serde::Serialize;
use serde_json::json;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use std::path::Path;
pub fn get_symbol_info() -> Tool {
Tool::new("get_symbol_info", "Retrieves information about the symbol at the specified position in the specified file.
@@ -215,10 +212,26 @@ pub fn find_references() -> Tool {
let path = call.resolve_readable(&call.str("filePath")?).await?;
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
let dir = super::scope::Scope::of(&call)?;
let opened = open_at(&call, path).await?;
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call.host.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
}).await?;
struct Close(std::sync::Arc<crate::Project>, ide_core::DocId);
impl Drop for Close { fn drop(&mut self) { self.0.documents.close(self.1); } }
let _close = Close(call.project.clone(), doc);
let pos = mcp_position(&text, line, column)?;
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
let result = race(&call, request, work, "references timed out; retry when analysis finishes").await?;
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, doc, pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
tokio::pin!(work);
let result = tokio::select! {
result = &mut work => result?,
_ = call.cancel.cancelled() => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::cancelled()); }
_ = tokio::time::sleep(std::time::Duration::from_secs(60)) => { call.host.cancel_request(request); let _ = work.await; return Err(IdeError::unavailable("references timed out; retry when analysis finishes")); }
};
let mut value = serde_json::to_value(&result).map_err(|e| IdeError::internal(e.to_string()))?;
// Convert every Location range at this boundary, including declarations.
fn positions(value: &mut serde_json::Value) {
@@ -261,266 +274,6 @@ pub fn find_references() -> Tool {
/// References `find_references` lists by default.
const REFERENCES_LIMIT: usize = 100;
/// A document a tool opened for the language services and the position it asked about;
/// dropping it closes the document.
#[must_use]
struct Opened {
project: Arc<crate::Project>,
doc: DocId,
pos: Pos,
}
impl Drop for Opened {
fn drop(&mut self) {
self.project.documents.close(self.doc);
}
}
/// Opens `path` at the call's 1-based `line` and `column`.
async fn open_at(call: &Call, path: PathBuf) -> IdeResult<Opened> {
let line = call.opt_i64("line")?.ok_or_else(|| IdeError::invalid("missing line"))?;
let column = call.opt_i64("column")?.ok_or_else(|| IdeError::invalid("missing column"))?;
let project = call.project.clone();
let (doc, text) = call
.host
.blocking(move || {
let text = project.text_of(&path)?;
let doc = project.documents.open(&path)?;
Ok((doc.id, text))
})
.await?;
let mut opened = Opened { project: call.project.clone(), doc, pos: Pos::default() };
opened.pos = mcp_position(&text, line, column)?;
Ok(opened)
}
/// How long a tool waits for a language service request.
const LANGUAGE_SERVICE_TIMEOUT: Duration = Duration::from_secs(60);
/// `work`, the language service `request`, until it ends; when the client cancels or
/// [`LANGUAGE_SERVICE_TIMEOUT`] passes first, the request is cancelled and `work` runs to its end.
async fn race<T>(
call: &Call,
request: RequestId,
work: impl Future<Output = IdeResult<T>>,
timed_out: &'static str,
) -> IdeResult<T> {
tokio::pin!(work);
tokio::select! {
result = &mut work => result,
_ = call.cancel.cancelled() => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::cancelled())
}
_ = tokio::time::sleep(LANGUAGE_SERVICE_TIMEOUT) => {
call.host.cancel_request(request);
let _ = work.await;
Err(IdeError::unavailable(timed_out))
}
}
}
pub fn get_call_hierarchy() -> Tool {
Tool::new(
"get_call_hierarchy",
"Callers (incoming) or callees (outgoing) of the function or method at the position, from \
the language server's call hierarchy. A position inside a function body means that function. \
One level per call: to go deeper, call again with an item's filePath, startLine and startColumn \
(items in libraries show a URI as filePath and cannot be expanded). \
Positions are 1-based UTF-16. `root` is the symbol the hierarchy is for; each item's callSites \
are where the call happens. Reports incomplete results when analysis is still running.",
call_hierarchy,
)
.param(Param::required("filePath", ParamType::String, "Path relative to the project root"))
.param(Param::required("line", ParamType::Integer, "1-based line"))
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
.param(super::scope::param())
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
}
/// Items `get_call_hierarchy` lists by default.
const CALLS_LIMIT: usize = 100;
/// Call sites shown per item; `callSiteCount` gives the total when there are more.
const MAX_CALL_SITES: usize = 20;
const CALLS_TIMED_OUT: &str = "call hierarchy timed out; retry when analysis finishes";
async fn call_hierarchy(call: Call) -> IdeResult<Output> {
let direction = match call.opt_str("direction")?.as_deref() {
None | Some("incoming") => HierarchyDirection::Incoming,
Some("outgoing") => HierarchyDirection::Outgoing,
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
};
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
let scope = super::scope::Scope::of(&call)?;
let path = call.resolve_readable(&call.str("filePath")?).await?;
let opened = open_at(&call, path).await?;
let hierarchy_at = |pos| {
let request = super::tool::request_id();
let work = crate::ops::lsp::lsp_call_hierarchy(&call.host, &call.window, request, opened.doc, pos, direction);
race(&call, request, work, CALLS_TIMED_OUT)
};
let mut found = match hierarchy_at(opened.pos).await {
// IDEA: inside a function body the hierarchy is the enclosing function's.
Err(e) if e.kind == ErrorKind::NotFound => {
let outline = tokio::select! {
outline = crate::ops::doc::doc_outline(&call.host, &call.window, opened.doc) => outline?,
_ = call.cancel.cancelled() => return Err(IdeError::cancelled()),
};
let at = enclosing_callable(&outline, opened.pos).map(|f| f.selection_range.start);
let Some(at) = at.filter(|at| *at != opened.pos) else {
let Pos { line, col } = opened.pos;
return Err(IdeError::not_found(format!("no function or method at {}:{}", line + 1, col + 1)));
};
hierarchy_at(at).await?
}
result => result?,
};
if scope.dir().is_some() {
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
}
let incomplete = found.incomplete;
let (mut root, items) = call_items(found, |p| call.display(p));
let mut out = serde_json::Map::new();
let mut items = page.take(items, &mut out);
// One file in memory at a time, as `search::fill_lines` reads them.
let mut places: Vec<&mut Place> = root
.iter_mut()
.chain(&mut items)
.flat_map(|i| std::iter::once(&mut i.at).chain(&mut i.call_sites))
.filter(|place| place.file.is_some())
.collect();
places.sort_by(|a, b| a.file.cmp(&b.file));
for in_file in places.chunk_by_mut(|a, b| a.file == b.file) {
if call.cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let Some(path) = in_file[0].file.clone() else { continue };
if let Ok(text) = crate::ops::fs::fs_read_text(&call.host, call.window(), path).await {
fill_line_texts(in_file, &text);
}
}
Output::json(CallHierarchyOutput { root, items, page: out, incomplete })
}
#[derive(Serialize)]
struct CallHierarchyOutput {
#[serde(skip_serializing_if = "Option::is_none")]
root: Option<CallItem>,
items: Vec<CallItem>,
/// `total`, and `more` and `nextOffset` when items follow.
#[serde(flatten)]
page: serde_json::Map<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
incomplete: Option<ReferencesIncomplete>,
}
/// A function or method in the call hierarchy, at its name.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct CallItem {
name: String,
kind: SymbolKind,
#[serde(skip_serializing_if = "Option::is_none")]
detail: Option<String>,
#[serde(flatten)]
at: Place,
#[serde(skip_serializing_if = "Vec::is_empty")]
call_sites: Vec<Place>,
#[serde(skip_serializing_if = "Option::is_none")]
call_site_count: Option<usize>,
}
/// A range as the tools show it: 1-based UTF-16, with the text of its first line.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Place {
file_path: String,
start_line: u32,
start_column: u32,
end_line: u32,
end_column: u32,
#[serde(skip_serializing_if = "Option::is_none")]
line_text: Option<String>,
/// The file `line_text` is read from; none in a library.
#[serde(skip)]
file: Option<PathBuf>,
}
/// The root and the items of `h`, sorted by file and position, with call sites in source
/// order, at most [`MAX_CALL_SITES`] per item. Library items show their URI.
fn call_items(h: CallHierarchy, display: impl Fn(&Path) -> String) -> (Option<CallItem>, Vec<CallItem>) {
let CallHierarchy { root, items, .. } = h;
// A file path, or the URI of a virtual document, which has no lines to read here.
let target = |path: &Path, uri: Option<&String>| match uri {
Some(uri) => (None, uri.clone()),
None => (Some(path.to_path_buf()), display(path)),
};
let place = |(file, file_path): (Option<PathBuf>, String), r: Range| Place {
file_path,
start_line: r.start.line + 1,
start_column: r.start.col + 1,
end_line: r.end.line + 1,
end_column: r.end.col + 1,
line_text: None,
file,
};
let convert = |i: HierarchyItem| {
let at = target(&i.path.0, i.uri.as_ref());
let sites_in = match &i.from_path {
Some(p) => {
let shown = p.0.to_string_lossy();
target(&p.0, ide_core::is_virtual_uri(&shown).then(|| shown.into_owned()).as_ref())
}
None => at.clone(),
};
let mut sites = i.from_ranges;
sites.sort();
sites.dedup();
let count = sites.len();
CallItem {
call_sites: sites.into_iter().take(MAX_CALL_SITES).map(|r| place(sites_in.clone(), r)).collect(),
call_site_count: (count > MAX_CALL_SITES).then_some(count),
at: place(at, i.selection_range),
name: i.name,
kind: i.kind,
detail: i.detail,
}
};
let mut items: Vec<CallItem> = items.into_iter().map(&convert).collect();
items.sort_by(|a, b| {
(&a.at.file_path, a.at.start_line, a.at.start_column).cmp(&(
&b.at.file_path,
b.at.start_line,
b.at.start_column,
))
});
(root.map(convert), items)
}
/// Fills `lineText` of `places`, which are all in the file whose text is `text`.
fn fill_line_texts(places: &mut [&mut Place], text: &str) {
let lines: Vec<&str> = text.split('\n').collect();
for place in places {
let Some(line) = lines.get(place.start_line as usize - 1) else { continue };
let line = line.strip_suffix('\r').unwrap_or(line);
let start = place.start_column as usize - 1;
let end = if place.end_line == place.start_line { place.end_column as usize - 1 } else { start };
place.line_text = Some(super::search::snippet(line, start, end));
}
}
/// The innermost function, method or constructor of `outline` whose extent holds `pos`,
/// as the IDE's Call Hierarchy finds it.
fn enclosing_callable(outline: &[OutlineItem], pos: Pos) -> Option<&OutlineItem> {
let item = outline.iter().find(|i| i.range.start <= pos && pos <= i.range.end)?;
enclosing_callable(&item.children, pos).or_else(|| {
matches!(item.kind, SymbolKind::Function | SymbolKind::Method | SymbolKind::Constructor).then_some(item)
})
}
fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
if line < 1 || line > u32::MAX as i64 || column < 1 || column > u32::MAX as i64 {
return Err(IdeError::invalid("line and column must be positive 1-based positions"));
@@ -531,156 +284,3 @@ fn mcp_position(text: &str, line: i64, column: i64) -> IdeResult<Pos> {
}
Ok(Pos::new((line - 1) as u32, (column - 1) as u32))
}
#[cfg(test)]
mod tests {
use super::*;
fn range(line: u32, col: u32, end_line: u32, end_col: u32) -> Range {
Range::new(Pos::new(line, col), Pos::new(end_line, end_col))
}
fn item(name: &str, path: &str, line: u32, from_ranges: Vec<Range>) -> HierarchyItem {
HierarchyItem {
name: name.into(),
kind: SymbolKind::Function,
detail: Some(format!("fn {name}()")),
path: PathBuf::from(path).into(),
uri: None,
range: range(line, 0, line + 2, 1),
selection_range: range(line, 3, line, 3 + name.len() as u32),
from_ranges,
from_path: None,
}
}
fn shown(path: &Path) -> String {
path.strip_prefix("/p").unwrap_or(path).to_string_lossy().into_owned()
}
fn hierarchy(root: HierarchyItem, items: Vec<HierarchyItem>) -> CallHierarchy {
CallHierarchy { root: Some(root), items, incomplete: None }
}
#[test]
fn incoming_call_sites_are_in_the_callers_file_one_based() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/src/main.rs", 2, vec![range(4, 8, 4, 13)])],
);
let (root, items) = call_items(h, shown);
let root = serde_json::to_value(root.unwrap()).unwrap();
assert_eq!(
root,
json!({"name":"price","kind":"function","detail":"fn price()","filePath":"src/lib.rs",
"startLine":11,"startColumn":4,"endLine":11,"endColumn":9})
);
assert_eq!(
serde_json::to_value(&items).unwrap(),
json!([{"name":"main","kind":"function","detail":"fn main()","filePath":"src/main.rs",
"startLine":3,"startColumn":4,"endLine":3,"endColumn":8,
"callSites":[{"filePath":"src/main.rs","startLine":5,"startColumn":9,"endLine":5,"endColumn":14}]}])
);
}
#[test]
fn outgoing_call_sites_are_in_the_file_ide_lsp_names() {
let mut price = item("price", "/p/src/lib.rs", 10, vec![range(4, 8, 4, 13)]);
price.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let (_, items) = call_items(hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![price]), shown);
assert_eq!(items[0].at.file_path, "src/lib.rs");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[0].call_sites[0].file.as_deref(), Some(Path::new("/p/src/main.rs")));
}
#[test]
fn library_items_show_their_uri() {
let mut library = item("len", "/virtual", 0, vec![range(4, 8, 4, 11)]);
library.uri = Some("jar:file:///lib.jar!/Str.class".into());
library.from_path = Some(PathBuf::from("/p/src/main.rs").into());
let mut called_from_library = item("parse", "/p/src/a.rs", 3, vec![range(1, 0, 1, 4)]);
called_from_library.from_path = Some(PathBuf::from("jdt://contents/lib.jar/Caller.class").into());
let h = hierarchy(item("main", "/p/src/main.rs", 2, Vec::new()), vec![library, called_from_library]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].at.file_path, "jar:file:///lib.jar!/Str.class");
assert_eq!(items[0].at.file, None, "no line text for a library item");
assert_eq!(items[0].call_sites[0].file_path, "src/main.rs");
assert_eq!(items[1].call_sites[0].file_path, "jdt://contents/lib.jar/Caller.class");
assert_eq!(items[1].call_sites[0].file, None);
}
#[test]
fn call_items_are_sorted_by_file_and_line() {
let h = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![
item("c", "/p/src/main.rs", 9, Vec::new()),
item("b", "/p/src/main.rs", 2, Vec::new()),
item("a", "/p/src/a.rs", 5, Vec::new()),
],
);
let (_, items) = call_items(h, shown);
assert_eq!(items.iter().map(|i| i.name.as_str()).collect::<Vec<_>>(), ["a", "b", "c"]);
}
#[test]
fn call_sites_are_capped_with_their_count() {
let sites = (0..MAX_CALL_SITES as u32 + 5).map(|l| range(l, 0, l, 1)).collect();
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
assert_eq!(items[0].call_sites.len(), MAX_CALL_SITES);
assert_eq!(items[0].call_site_count, Some(MAX_CALL_SITES + 5));
let one = hierarchy(
item("price", "/p/src/lib.rs", 10, Vec::new()),
vec![item("main", "/p/a.rs", 0, vec![range(1, 0, 1, 1)])],
);
assert_eq!(call_items(one, shown).1[0].call_site_count, None);
}
#[test]
fn call_sites_are_in_source_order_without_duplicates() {
let sites = vec![range(5, 0, 5, 1), range(1, 4, 1, 5), range(5, 0, 5, 1), range(1, 2, 1, 3)];
let h = hierarchy(item("price", "/p/src/lib.rs", 10, Vec::new()), vec![item("main", "/p/a.rs", 0, sites)]);
let (_, items) = call_items(h, shown);
let at: Vec<_> = items[0].call_sites.iter().map(|s| (s.start_line, s.start_column)).collect();
assert_eq!(at, [(2, 3), (2, 5), (6, 1)]);
assert_eq!(items[0].call_site_count, None);
}
#[test]
fn line_text_is_cut_from_the_line_of_each_place() {
let h = hierarchy(item("price", "/p/src/lib.rs", 3, vec![range(0, 4, 0, 9), range(1, 0, 3, 1)]), Vec::new());
let mut root = call_items(h, shown).0.unwrap();
let mut places: Vec<&mut Place> = std::iter::once(&mut root.at).chain(&mut root.call_sites).collect();
fill_line_texts(&mut places, " price();\r\nfn other() {\n\nfn price() {}");
assert_eq!(root.at.line_text.as_deref(), Some("fn price() {}"));
assert_eq!(root.call_sites[0].line_text.as_deref(), Some(" price();"));
assert_eq!(root.call_sites[1].line_text.as_deref(), Some("fn other() {"), "a range over lines");
}
#[test]
fn enclosing_callable_is_the_innermost_function() {
let outline = |name: &str, kind, range, children| OutlineItem {
name: name.into(),
detail: None,
kind,
range,
selection_range: Range::new(range.start, range.start),
children,
visibility: None,
};
let method = outline(
"total",
SymbolKind::Method,
range(2, 4, 8, 5),
vec![outline("add", SymbolKind::Function, range(3, 8, 5, 9), Vec::new())],
);
let items = vec![outline("Cart", SymbolKind::Struct, range(0, 0, 9, 1), vec![method])];
let name = |pos| enclosing_callable(&items, pos).map(|i| i.name.as_str());
assert_eq!(name(Pos::new(4, 0)), Some("add"));
assert_eq!(name(Pos::new(5, 9)), Some("add"), "the end is inside");
assert_eq!(name(Pos::new(7, 0)), Some("total"));
assert_eq!(name(Pos::new(0, 3)), None, "a struct is not callable");
assert_eq!(name(Pos::new(12, 0)), None);
}
}
+147 -207
Переглянути файл
@@ -1,8 +1,9 @@
//! Agents tool window: coding agent tasks of the project (over ACP). In a remote
//! window they run on the host, next to the project they work on.
use super::Channel;
use super::{Channel, Emit};
use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use crate::rpc::Dispatcher;
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentEntry,
@@ -10,7 +11,6 @@ use ide_agent::{
ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_tools::InstallEvent;
@@ -18,47 +18,32 @@ use std::collections::HashSet;
use std::sync::{LazyLock, Mutex};
/// Streams the project's agent events to this window; returns every task.
#[command(trust = always)]
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
let _ = on_event.send(e);
})))
pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
Ok(host.project(window)?.agents.subscribe(on_event))
}
#[command(trust = trusted)]
pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
host.require_trust(window)?;
let mut providers = host.project(window)?.agents.providers();
ide_agent::registry::mark_updates(&registry_paths(host), &mut providers);
Ok(providers)
}
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
#[command(trust = trusted)]
pub fn agent_refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
// Refreshes the selected agent's model catalog without sending a prompt.
/// Refreshes the selected agent's model catalog without sending a prompt.
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
host.project(window)?.agents.refresh_models(&provider, force)
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
/// built-in's driver and arguments), or returns it to auto-detection with `None`.
#[command(trust = trusted)]
pub fn agent_set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
pub fn set_command(host: &Host, window: &str, id: String, command: Option<String>) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_builtin_command(&id, command)
}
/// Environment variables built-in agent `id` starts with (saved in its agent file);
/// an empty map clears them.
#[command(trust = trusted)]
pub fn agent_set_env(
/// Environment variables built-in agent `id` starts with; empty clears them.
pub fn set_env(
host: &Host,
window: &str,
id: String,
@@ -97,8 +82,7 @@ fn join_err(e: impl std::fmt::Display) -> IdeError {
/// Agents of the ACP Registry this machine can run, with what is installed; the list
/// saved earlier when the registry is unreachable. Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn agent_registry_list(host: &Host, request: RequestId) -> IdeResult<AgentRegistry> {
pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> IdeResult<AgentRegistry> {
let paths = registry_paths(host);
let cancel = host.begin_request(request);
let result =
@@ -140,15 +124,15 @@ impl Drop for Installing {
}
/// Installs the registry's current version of agent `id` (also to update it), streaming
/// progress through `on_event`. Cancel with `cancel_request(request)`.
#[command(trust = always)]
pub async fn agent_registry_install(
/// progress through `on_event`; the agent then shows in `agent_providers`. Cancel with
/// `cancel_request(request)`.
pub async fn registry_install(
host: &Host,
_window: &str,
id: String,
request: RequestId,
on_event: Channel<InstallEvent>,
) -> IdeResult<()> {
// The agent then shows in `agent_providers`.
let paths = registry_paths(host);
let installing = Installing::begin(&id)?;
let cancel = host.begin_request(request);
@@ -199,8 +183,7 @@ pub async fn agent_registry_install(
}
/// Removes a registry agent: its agent file and installed files.
#[command(trust = always)]
pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
pub async fn registry_remove(host: &Host, _window: &str, id: String) -> IdeResult<()> {
let paths = registry_paths(host);
tokio::task::spawn_blocking(move || ide_agent::registry::remove(&paths, &id)).await.map_err(join_err)??;
for project in host.projects() {
@@ -211,8 +194,7 @@ pub async fn agent_registry_remove(host: &Host, id: String) -> IdeResult<()> {
/// Slash commands to complete for `provider` in `task`'s directory, or in the project
/// before a task exists (skills and custom commands on disk included).
#[command(trust = always)]
pub async fn agent_commands(
pub async fn commands(
host: &Host,
window: &str,
provider: String,
@@ -222,36 +204,26 @@ pub async fn agent_commands(
}
/// Entries of `task`'s conversation, or of its subagent `subagent`'s.
#[command(trust = always)]
pub fn agent_entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
pub fn entries(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<Vec<AgentEntry>> {
host.project(window)?.agents.entries(&task, subagent)
}
/// Sessions of the project on this machine that no task holds yet, newest first.
#[command(trust = trusted)]
pub async fn agent_external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
// Reads transcripts from disk on the blocking pool.
/// Sessions of the project on this machine that no task holds yet, newest first. Reads
/// transcripts from disk on the blocking pool.
pub async fn external_sessions(host: &Host, window: &str) -> IdeResult<Vec<ExternalSession>> {
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.external_sessions()).await.map_err(join_err)
}
/// Imports an external session as a task: its first turn loads and replays it.
#[command(trust = trusted)]
pub async fn agent_import_session(
host: &Host,
window: &str,
provider: String,
session_id: String,
) -> IdeResult<AgentTask> {
pub async fn import_session(host: &Host, window: &str, provider: String, session_id: String) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let agents = host.project(window)?.agents.clone();
tokio::task::spawn_blocking(move || agents.import_session(&provider, &session_id)).await.map_err(join_err)?
}
#[command(trust = trusted)]
pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> IdeResult<AgentTask> {
pub async fn create(host: &Host, window: &str, mut request: NewAgentTask) -> IdeResult<AgentTask> {
host.require_trust(window)?;
let mut request = request;
let project = host.project(window)?;
let root = project.root.clone();
let requested = request.project_root.take();
@@ -262,136 +234,98 @@ pub async fn agent_create(host: &Host, window: &str, request: NewAgentTask) -> I
}
/// Sends a message; while the agent works it is queued, or with `now` it interrupts the turn.
#[command(trust = trusted)]
pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
pub async fn prompt(host: &Host, window: &str, task: String, prompt: AgentPrompt, now: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.prompt(&task, prompt, now).await
}
/// Answers a non-blocking question, without cancelling the current turn.
#[command(trust = trusted)]
pub async fn agent_answer_question(
host: &Host,
window: &str,
task: String,
question: String,
answer: Option<String>,
) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.answer_question(&task, &question, answer).await
}
/// Drops a queued message and returns it (to edit it).
#[command(trust = always)]
pub fn agent_unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
pub fn unqueue(host: &Host, window: &str, task: String, queued: String) -> IdeResult<AgentQueued> {
host.project(window)?.agents.unqueue(&task, &queued)
}
/// Sends a queued message now, interrupting the current turn.
#[command(trust = trusted)]
pub async fn agent_send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
pub fn send_queued_now(host: &Host, window: &str, task: String, queued: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.send_queued_now(&task, &queued).await
host.project(window)?.agents.send_queued_now(&task, &queued)
}
/// Changes a session setting (model, mode, thinking effort…).
#[command(trust = trusted)]
pub async fn agent_set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
pub async fn set_config(host: &Host, window: &str, task: String, option: String, value: String) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.set_config(&task, &option, value).await
}
/// Copies the task's conversation into a new task, up to its first `turns` turns (all when `None`).
#[command(trust = trusted)]
pub async fn agent_fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
pub async fn fork(host: &Host, window: &str, task: String, turns: Option<u32>) -> IdeResult<AgentTask> {
host.require_trust(window)?;
host.project(window)?.agents.fork(&task, turns).await
}
/// Drops the task's turns after its first `turns`; returns the message of the first dropped one.
#[command(trust = trusted)]
pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
pub async fn rollback(host: &Host, window: &str, task: String, turns: u32) -> IdeResult<Option<AgentPrompt>> {
host.require_trust(window)?;
host.project(window)?.agents.rollback(&task, turns).await
}
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
/// What the agent reports about itself when it starts, without opening a session.
pub async fn probe(host: &Host, window: &str, provider: String, refresh: bool) -> IdeResult<AgentProbe> {
host.require_trust(window)?;
host.project(window)?.agents.probe(&provider, refresh).await
}
/// Stops the task's current turn, or with `subagent` only that subagent's work.
#[command(trust = always)]
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
pub fn cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
host.project(window)?.agents.cancel(&task, subagent)
}
/// Stops one of the task's background tasks.
#[command(trust = always)]
pub async fn agent_stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
pub async fn stop_background(host: &Host, window: &str, task: String, background: String) -> IdeResult<()> {
host.project(window)?.agents.stop_background(&task, &background).await
}
/// Answers a permission request; `option: null` cancels it.
#[command(trust = trusted)]
pub fn agent_respond(
host: &Host,
window: &str,
task: String,
permission: u32,
option: Option<String>,
) -> IdeResult<()> {
/// Answers a permission request; `option: None` cancels it.
pub fn respond(host: &Host, window: &str, task: String, permission: u32, option: Option<String>) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.respond(&task, permission, option)
}
#[command(trust = always)]
pub fn agent_archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
pub fn archive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.archive(&task)
}
#[command(trust = always)]
pub fn agent_unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
pub fn unarchive(host: &Host, window: &str, task: String) -> IdeResult<()> {
host.project(window)?.agents.unarchive(&task)
}
#[command(trust = trusted)]
pub fn agent_rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
pub fn rename(host: &Host, window: &str, task: String, title: String) -> IdeResult<()> {
host.project(window)?.agents.rename(&task, &title)
}
#[command(trust = trusted)]
pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
pub async fn delete(host: &Host, window: &str, task: String, remove_worktree: bool) -> IdeResult<()> {
host.require_trust(window)?;
host.project(window)?.agents.delete(&task, remove_worktree).await
}
#[command(trust = trusted)]
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
pub async fn changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
host.require_trust(window)?;
host.project(window)?.agents.changes(&task).await
}
/// The task's uncommitted changes and the commits made since it started.
#[command(trust = trusted)]
pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
pub async fn grouped_changes(host: &Host, window: &str, task: String) -> IdeResult<AgentChanges> {
host.require_trust(window)?;
host.project(window)?.agents.grouped_changes(&task).await
}
/// Content of `path` when the task started (left side of its diff).
#[command(trust = trusted)]
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
pub async fn base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
host.require_trust(window)?;
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
}
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
#[command(trust = trusted)]
pub async fn agent_rollback_changes(
pub async fn rollback_changes(
host: &Host,
window: &str,
task: String,
@@ -404,8 +338,7 @@ pub async fn agent_rollback_changes(
/// Accept: copies a worktree task's changed files among `paths` (all without) into the
/// local checkout, uncommitted; files the checkout changed itself are left alone and reported.
#[command(trust = trusted)]
pub async fn agent_accept_changes(
pub async fn accept_changes(
host: &Host,
window: &str,
task: String,
@@ -518,7 +451,6 @@ fn persist_mcp_map(
host.global_settings.set(ide_workspace::settings::SettingsScope::Global, "agents.mcpServers", value)?;
for p in host.projects() {
p.settings.reload();
p.agents.notify_mcp_servers_changed();
p.sink.emit(event.clone());
if kept == Kept::LocalFile {
host.agent_secrets.notify_kept_locally(&p.sink);
@@ -528,7 +460,6 @@ fn persist_mcp_map(
McpScope::Workspace => {
let p = project.ok_or_else(|| IdeError::invalid("Open a project to configure workspace MCP servers"))?;
p.settings.set(ide_workspace::settings::SettingsScope::Project, "agents.mcpServers", value)?;
p.agents.notify_mcp_servers_changed();
p.sink.emit(event);
}
}
@@ -596,31 +527,20 @@ pub(crate) fn session_mcp_servers(
use ide_workspace::settings::SettingsScope;
let mut user = settings.layer(SettingsScope::Global).agents.mcp_servers;
fill_mcp_values(secrets, &mut user);
let raw_workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
let workspace = approvals.apply(root, raw_workspace.clone());
let mut out = ide_agent::mcp::servers_from_settings(&user, &workspace);
for srv in &mut out {
if srv.scope == McpScope::Workspace
&& let Some(raw) = raw_workspace.get(&srv.name)
{
srv.unapproved = !approvals.approved(root, &srv.name, raw);
}
}
out
let mut workspace = settings.layer(SettingsScope::Project).agents.mcp_servers;
workspace.retain(|name, srv| approvals.approved(root, name, srv));
ide_agent::mcp::servers_from_settings(&user, &workspace)
}
/// Lists configured and discovered MCP servers across User, Workspace, Plugin, and Built-In scopes.
#[command(trust = always)]
pub fn agent_mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// Configured servers of the User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
/// Lists configured MCP servers across User (`settings.toml`) and Workspace (`.openidea/settings.toml`) scopes.
pub fn mcp_list(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
let (user, workspace, project) = mcp_maps(host, window);
Ok(listed(host, project.as_ref(), &user, workspace))
}
/// Creates or updates a User or Workspace MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
// A Workspace server saved here is one the user turned on.
/// Creates or updates a User or Workspace MCP server and returns the updated list. A Workspace
/// server saved here is one the user turned on.
pub fn mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> =
(input.scope == McpScope::Workspace).then(|| input.name.trim().to_owned()).into_iter().collect();
update_mcp_maps(host, window, &approve, |user, workspace, project_root| {
@@ -629,9 +549,8 @@ pub fn agent_mcp_save(host: &Host, window: &str, input: McpServerInput) -> IdeRe
}
/// Parses and saves one or more MCP servers from a pasted JSON snippet (`{"mcpServers": {...}}` or
/// single server object).
#[command(trust = always)]
pub fn agent_mcp_save_json(
/// single server object). Workspace servers explicitly saved here by the user are approved.
pub fn mcp_save_json(
host: &Host,
window: &str,
scope: McpScope,
@@ -639,7 +558,6 @@ pub fn agent_mcp_save_json(
fallback_name: Option<String>,
agents: Vec<String>,
) -> IdeResult<Vec<McpServer>> {
// Workspace servers explicitly saved here by the user are approved.
update_mcp_maps(host, window, &[], |user, workspace, project_root| {
let saved = ide_agent::mcp::apply_save_json(
user,
@@ -655,8 +573,7 @@ pub fn agent_mcp_save_json(
}
/// Enables or disables an MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
pub fn mcp_set_enabled(host: &Host, window: &str, id: String, enabled: bool) -> IdeResult<Vec<McpServer>> {
let approve: Vec<String> = ide_agent::mcp::parse_server_id(&id)
.filter(|(scope, _)| enabled && *scope == McpScope::Workspace)
.map(|(_, name)| name.to_owned())
@@ -668,17 +585,15 @@ pub fn agent_mcp_set_enabled(host: &Host, window: &str, id: String, enabled: boo
}
/// Removes a User or Workspace MCP server and returns the updated list.
#[command(trust = always)]
pub fn agent_mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
pub fn mcp_remove(host: &Host, window: &str, id: String) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |user, workspace, _| {
ide_agent::mcp::apply_remove(user, workspace, &id).map(|_| Vec::new())
})
}
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once.
#[command(trust = always)]
pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
// They stay off until the user turns them on.
/// Copies MCP servers from `.mcp.json` and `.vscode/mcp.json` into the workspace settings once;
/// they stay off until the user turns them on.
pub fn mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>> {
update_mcp_maps(host, window, &[], |_, workspace, project_root| {
let root = project_root.ok_or_else(|| "Open a project to import workspace MCP servers".to_string())?;
ide_agent::mcp::apply_import(workspace, root);
@@ -687,8 +602,7 @@ pub fn agent_mcp_import(host: &Host, window: &str) -> IdeResult<Vec<McpServer>>
}
/// Discovers external MCP configuration files on disk (CLI user configs + workspace `.mcp.json`).
#[command(trust = always)]
pub async fn agent_mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
pub async fn mcp_discover_sources(host: &Host, window: &str) -> IdeResult<Vec<McpExternalSource>> {
let project_root = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
let home = dirs::home_dir();
tokio::task::spawn_blocking(move || {
@@ -699,15 +613,14 @@ pub async fn agent_mcp_discover_sources(host: &Host, window: &str) -> IdeResult<
}
/// Imports selected servers from discovered external MCP configuration files into User or Workspace scope.
#[command(trust = always)]
pub async fn agent_mcp_import_selected(
/// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
pub async fn mcp_import_selected(
host: &Host,
window: &str,
scope: McpScope,
selections: Vec<McpImportSelection>,
overwrite: bool,
) -> IdeResult<Vec<McpServer>> {
// Imported Workspace entries remain unapproved (disabled) until the user explicitly enables them.
let home = dirs::home_dir();
update_mcp_maps(host, window, &[], move |user, workspace, project_root| {
ide_agent::mcp::apply_import_selected(
@@ -724,8 +637,7 @@ pub async fn agent_mcp_import_selected(
}
/// Tests an MCP server by connecting (`initialize`) and listing its tools (`tools/list`).
#[command(trust = trusted)]
pub async fn agent_mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
pub async fn mcp_test(host: &Host, window: &str, id: String) -> IdeResult<McpProbeResult> {
host.require_trust(window)?;
let (user, workspace, project) = mcp_maps(host, window);
let (scope, name) = ide_agent::mcp::parse_server_id(&id)
@@ -800,10 +712,7 @@ async fn probe_http_mcp_server(server: &ide_core::settings::AgentMcpServer) -> M
if let Some(sid) = session_id.as_deref() {
req = req.header("Mcp-Session-Id", sid);
}
let resp = req
.send()
.await
.map_err(|e| format!("Request to `{url}` failed: {}", ide_http::client::describe(&e.without_url())))?;
let resp = req.send().await.map_err(|e| format!("Request to `{url}` failed: {e}"))?;
let status = resp.status();
let next_session =
resp.headers().get("mcp-session-id").and_then(|v| v.to_str().ok()).map(str::to_owned).or(session_id);
@@ -905,9 +814,8 @@ fn parse_mcp_http_response(body: &str) -> Result<serde_json::Value, String> {
Err("Unexpected non-JSON MCP response".into())
}
/// Updates per-session MCP server enable/disable overrides on `task`.
#[command(trust = always)]
pub fn agent_set_mcp_overrides(
/// Updates per-session MCP server enable/disable overrides on task `task`.
pub fn set_mcp_overrides(
host: &Host,
window: &str,
task: String,
@@ -916,6 +824,85 @@ pub fn agent_set_mcp_overrides(
host.project(window)?.agents.set_mcp_overrides(&task, overrides)
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
d.add("agent_refresh_models", |c| async move {
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
});
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
d.add("agent_registry_list", |c| async move { registry_list(&c.host, &c.window, c.arg("request")?).await });
d.add("agent_registry_install", |c| async move {
registry_install(&c.host, &c.window, c.arg("id")?, c.arg("request")?, c.sender("onEvent")?).await
});
d.add("agent_registry_remove", |c| async move { registry_remove(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_mcp_list", |c| async move { mcp_list(&c.host, &c.window) });
d.add("agent_mcp_save", |c| async move { mcp_save(&c.host, &c.window, c.arg("input")?) });
d.add("agent_mcp_save_json", |c| async move {
mcp_save_json(&c.host, &c.window, c.arg("scope")?, c.arg("rawJson")?, c.arg("fallbackName")?, c.arg("agents")?)
});
d.add(
"agent_mcp_set_enabled",
|c| async move { mcp_set_enabled(&c.host, &c.window, c.arg("id")?, c.arg("enabled")?) },
);
d.add("agent_mcp_remove", |c| async move { mcp_remove(&c.host, &c.window, c.arg("id")?) });
d.add("agent_mcp_import", |c| async move { mcp_import(&c.host, &c.window) });
d.add("agent_mcp_discover_sources", |c| async move { mcp_discover_sources(&c.host, &c.window).await });
d.add("agent_mcp_import_selected", |c| async move {
mcp_import_selected(&c.host, &c.window, c.arg("scope")?, c.arg("selections")?, c.arg("overwrite")?).await
});
d.add("agent_mcp_test", |c| async move { mcp_test(&c.host, &c.window, c.arg("id")?).await });
d.add("agent_set_mcp_overrides", |c| async move {
set_mcp_overrides(&c.host, &c.window, c.arg("task")?, c.arg("overrides")?)
});
d.add("agent_commands", |c| async move { commands(&c.host, &c.window, c.arg("provider")?, c.arg("task")?).await });
d.add("agent_entries", |c| async move { entries(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_create", |c| async move { create(&c.host, &c.window, c.arg("request")?).await });
d.add("agent_external_sessions", |c| async move { external_sessions(&c.host, &c.window).await });
d.add("agent_import_session", |c| async move {
import_session(&c.host, &c.window, c.arg("provider")?, c.arg("sessionId")?).await
});
d.add("agent_prompt", |c| async move {
prompt(&c.host, &c.window, c.arg("task")?, c.arg("prompt")?, c.arg("now")?).await
});
d.add("agent_unqueue", |c| async move { unqueue(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) });
d.add(
"agent_send_queued_now",
|c| async move { send_queued_now(&c.host, &c.window, c.arg("task")?, c.arg("queued")?) },
);
d.add("agent_set_config", |c| async move {
set_config(&c.host, &c.window, c.arg("task")?, c.arg("option")?, c.arg("value")?).await
});
d.add("agent_fork", |c| async move { fork(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_rollback", |c| async move { rollback(&c.host, &c.window, c.arg("task")?, c.arg("turns")?).await });
d.add("agent_probe", |c| async move { probe(&c.host, &c.window, c.arg("provider")?, c.arg("refresh")?).await });
d.add("agent_cancel", |c| async move { cancel(&c.host, &c.window, c.arg("task")?, c.arg("subagent")?) });
d.add("agent_stop_background", |call| async move {
stop_background(&call.host, &call.window, call.arg("task")?, call.arg("background")?).await
});
d.add("agent_respond", |c| async move {
respond(&c.host, &c.window, c.arg("task")?, c.arg("permission")?, c.arg("option")?)
});
d.add("agent_unarchive", |c| async move { unarchive(&c.host, &c.window, c.arg("task")?) });
d.add("agent_rename", |c| async move { rename(&c.host, &c.window, c.arg("task")?, c.arg("title")?) });
d.add("agent_archive", |c| async move { archive(&c.host, &c.window, c.arg("task")?) });
d.add(
"agent_delete",
|c| async move { delete(&c.host, &c.window, c.arg("task")?, c.arg("removeWorktree")?).await },
);
d.add("agent_changes", |c| async move { changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_grouped_changes", |c| async move { grouped_changes(&c.host, &c.window, c.arg("task")?).await });
d.add("agent_base_text", |c| async move { base_text(&c.host, &c.window, c.arg("task")?, c.arg("path")?).await });
d.add("agent_rollback_changes", |c| async move {
rollback_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?, c.arg("view")?).await
});
d.add("agent_accept_changes", |c| async move {
accept_changes(&c.host, &c.window, c.arg("task")?, c.arg("paths")?).await
});
}
fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::Path>) -> IdeResult<std::path::PathBuf> {
let Some(requested) = requested else {
return Ok(root.to_path_buf());
@@ -1024,50 +1011,3 @@ mod tests {
assert!(!reloaded.approved(&tmp.path().join("other"), "extra", &extra));
}
}
ide_command::domain!(
agent:
agent_accept_changes,
agent_answer_question,
agent_archive,
agent_base_text,
agent_cancel,
agent_changes,
agent_commands,
agent_create,
agent_delete,
agent_entries,
agent_external_sessions,
agent_fork,
agent_grouped_changes,
agent_import_session,
agent_mcp_discover_sources,
agent_mcp_import,
agent_mcp_import_selected,
agent_mcp_list,
agent_mcp_remove,
agent_mcp_save,
agent_mcp_save_json,
agent_mcp_set_enabled,
agent_mcp_test,
agent_probe,
agent_prompt,
agent_providers,
agent_refresh_models,
agent_registry_install,
agent_registry_list,
agent_registry_remove,
agent_rename,
agent_respond,
agent_rollback,
agent_rollback_changes,
agent_send_queued_now,
agent_set_command,
agent_set_config,
agent_set_env,
agent_set_mcp_overrides,
agent_stop_background,
agent_subscribe,
agent_unarchive,
agent_unqueue,
);
+18 -16
Переглянути файл
@@ -6,7 +6,7 @@
use crate::Host;
use crate::Project;
use crate::ops::Channel;
use ide_command::command;
use crate::rpc::Dispatcher;
use super::doc::blocking;
use ide_analysis::{
@@ -122,7 +122,6 @@ pub struct StructuralLanguage {
/// Inspect Code: diagnostics of every file in `scope` that a language server
/// serves. Files stream through `on_event` as they finish; ends with `Done`.
#[command(trust = trusted)]
pub async fn inspect_code(
host: &Host,
window: &str,
@@ -196,7 +195,6 @@ pub async fn inspect_code(
}
/// Locate Duplicates over the files of `scope`.
#[command(trust = always)]
pub async fn analysis_locate_duplicates(
host: &Host,
window: &str,
@@ -219,8 +217,7 @@ pub async fn analysis_locate_duplicates(
}
/// Languages Search Structurally supports (those with a bundled grammar).
#[command(trust = always)]
pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLanguage>> {
pub async fn structural_languages(host: &Host, _window: &str) -> IdeResult<Vec<StructuralLanguage>> {
let syntax = host.syntax();
let mut out: Vec<StructuralLanguage> = host
.languages
@@ -234,8 +231,7 @@ pub async fn structural_languages(host: &Host) -> IdeResult<Vec<StructuralLangua
}
/// Checks a structural search template (and language) while the user types.
#[command(trust = always)]
pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResult<()> {
pub async fn structural_validate(host: &Host, _window: &str, query: StructuralQuery) -> IdeResult<()> {
let syntax = host.syntax();
blocking(move || ide_analysis::validate_structural(&syntax, &query)).await
}
@@ -243,7 +239,6 @@ pub async fn structural_validate(host: &Host, query: StructuralQuery) -> IdeResu
/// Search Structurally over `scope`; files with matches stream through
/// `on_event`, ending with `Done`. With a replacement, matches carry their
/// replacement text (applied by the UI as a workspace edit).
#[command(trust = always)]
pub async fn structural_search(
host: &Host,
window: &str,
@@ -270,11 +265,18 @@ pub async fn structural_search(
Ok(())
}
ide_command::domain!(
analysis:
analysis_locate_duplicates,
inspect_code,
structural_languages,
structural_search,
structural_validate,
);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("inspect_code", |c| async move {
inspect_code(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.sender("onEvent")?).await
});
d.add("analysis_locate_duplicates", |c| async move {
analysis_locate_duplicates(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("options")?).await
});
d.add("structural_languages", |c| async move { structural_languages(&c.host, &c.window).await });
d.add("structural_validate", |c| async move { structural_validate(&c.host, &c.window, c.arg("query")?).await });
d.add("structural_search", |c| async move {
structural_search(&c.host, &c.window, c.arg("request")?, c.arg("scope")?, c.arg("query")?, c.sender("onEvent")?)
.await
});
}
+98 -110
Переглянути файл
@@ -4,8 +4,8 @@ mod workspace;
use super::dependencies::{MavenCentralArtifacts, MavenCentralGroups, MavenCentralVersions};
use crate::ops::Channel;
use crate::{Host, Project};
use ide_command::command;
use crate::rpc::Dispatcher;
use crate::{Host, Project, apply_workspace_edit};
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
use ide_build::maven::PomGoto;
@@ -126,7 +126,6 @@ fn with_profiles(mut model: BuildModel, cache: &Path) -> BuildModel {
}
/// Maven and Gradle projects of the window's project, from the build files plus the last sync.
#[command(trust = trusted)]
pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -203,15 +202,13 @@ async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link
.map_err(join_err)?
}
#[command(trust = trusted)]
/// Links independent builds without changing their Gradle scripts.
pub async fn gradle_link_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Links independent builds without changing their Gradle scripts.
set_gradle_projects(host, window, paths, true).await
}
#[command(trust = trusted)]
/// Stops importing the selected independent builds; files and saved run configurations stay intact.
pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
// Stops importing the selected independent builds; files and saved run configurations stay intact.
set_gradle_projects(host, window, paths, false).await
}
@@ -219,7 +216,6 @@ pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String
/// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
/// Returns the refreshed model; a failed build is reported in its `syncError`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_sync(
host: &Host,
window: &str,
@@ -315,11 +311,12 @@ pub async fn build_sync(
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
// Gradle may report project folders outside the project (`includeFlat`), and a Maven
// reactor may have gained or dropped modules beside it: index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
if tool == BuildTool::Gradle {
// The sync may report project folders outside the project (`includeFlat`): index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
}
// New source folders and dependency versions: the Project view and External Libraries reload.
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
if tool == BuildTool::Maven
@@ -423,8 +420,7 @@ fn declaring_pom(
}
/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
/// build has downloaded it.
#[command(trust = trusted)]
/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
pub async fn gradle_published_catalog(
host: &Host,
window: &str,
@@ -439,8 +435,8 @@ pub async fn gradle_published_catalog(
.map_err(join_err)
}
/// The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer).
#[command(trust = trusted)]
/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
pub async fn gradle_dependencies(
host: &Host,
window: &str,
@@ -450,7 +446,6 @@ pub async fn gradle_dependencies(
request: RequestId,
build_dir: Option<String>,
) -> IdeResult<Vec<ide_build::GradleDependency>> {
// `gradle_path` is `:`, `:app`…; the tree comes from Gradle's `dependencies` report.
host.require_trust(window)?;
let project = host.project(window)?;
let config = host.config_dir.clone();
@@ -473,15 +468,7 @@ pub async fn gradle_dependencies(
gradle_command: Some(gradle.command.clone()),
..Default::default()
};
let dependencies =
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)?;
// What plugins read of the build (`build.dependencies`) instead of running Gradle.
let report = ide_build::GradleReport { project: gradle_path, configuration, dependencies };
let cache = ide_build::gradle::cache_dir(&scope.cache, &gradle.dir);
if let Err(e) = ide_build::save_gradle_report(&scope.root, &cache, gradle, &report) {
tracing::debug!("keeping the dependencies report of {}: {e}", report.project);
}
Ok(report.dependencies)
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
})
.await
.map_err(join_err);
@@ -489,42 +476,7 @@ pub async fn gradle_dependencies(
result?
}
/// What the Dependency Analyzer has of the builds of `project` at `root` (the project, or one
/// of its workspace members), without running a build tool: the Maven modules as last synced
/// and the Gradle reports read since the build files last changed.
pub(crate) fn analyzed_dependencies(
project: &Project,
config: &Path,
root: &Path,
) -> IdeResult<crate::plugins::BuildGraph> {
let mut graph = crate::plugins::BuildGraph::default();
for scope in workspace::scopes(project, config)?.iter().filter(|s| root == project.root || s.root == root) {
let settings = &scope.settings;
let model = ide_build::load_linked(
&scope.root,
&scope.cache,
ide_sdk::apply::maven_local_repository(&scope.root, settings),
&settings.languages.java.maven,
&settings.languages.java.gradle,
);
graph.maven.extend(model.maven.into_iter().flat_map(|m| m.projects));
for build in &model.gradle {
let reports =
ide_build::gradle_reports(&scope.root, &ide_build::gradle::cache_dir(&scope.cache, &build.dir), build);
// buildSrc can't be analyzed from the build, as in the Dependency Analyzer.
for p in build.projects.iter().filter(|p| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"))) {
graph.gradle.push(crate::plugins::GradleModule {
path: p.path.clone(),
reports: reports.iter().filter(|r| r.project == p.path).cloned().collect(),
});
}
}
}
Ok(graph)
}
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
#[command(trust = trusted)]
pub async fn maven_dependency_declaration(
host: &Host,
window: &str,
@@ -541,15 +493,14 @@ pub async fn maven_dependency_declaration(
.map_err(join_err)?
}
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
/// The go-to-declaration target at `pos` of the Maven POM `pom` (project-relative, or
/// absolute for a parent POM opened from the local repository): the definition of the
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
/// entry providing the dependency's / plugin's version, along the parent chain.
#[command(trust = trusted)]
/// entry providing the dependency's / plugin's version, along the parent chain (into
/// the local repository when a parent is not in the project), else the artifact's own
/// POM (a project module's, or the local repository's). `None` when nothing
/// resolvable is under the caret.
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
// The parent chain reaches into the local repository when a parent is not in the project;
// without a managed version the target is the artifact's own POM (a project module's, or the
// local repository's). `None` when nothing resolvable is under the caret.
let project = host.project(window)?;
tokio::task::spawn_blocking(move || {
let given = Path::new(&pom);
@@ -580,8 +531,12 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
/// Completion of the `<dependency>` coordinate the caret (`offset`, UTF-16) sits
/// in the value of in the POM `doc`, from the local repository and Maven Central.
#[command(trust = trusted)]
/// in the value of in the POM `doc`: the coordinates installed in the local
/// repository (Settings › Maven's, else `~/.m2/repository`) — group ids,
/// the chosen group's artifacts, the chosen artifact's versions — topped up
/// with Maven Central's (the search endpoint's popular coordinates, the
/// published version metadata), which the shared version cache keeps for the
/// session. `None` when the caret is not in a `<dependency>` coordinate element.
pub async fn maven_dependency_completion(
host: &Host,
window: &str,
@@ -589,10 +544,6 @@ pub async fn maven_dependency_completion(
offset: u32,
request: RequestId,
) -> IdeResult<Option<PomCompletion>> {
// The local repository is Settings › Maven's, else `~/.m2/repository` (group ids, the chosen
// group's artifacts, the chosen artifact's versions), topped up with Maven Central's (the search
// endpoint's popular coordinates, the published version metadata), which the shared version
// cache keeps for the session. `None` when the caret is not in a `<dependency>` coordinate element.
use ide_build::maven::completion::{PomCompletionKind, local_options};
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
@@ -662,7 +613,6 @@ pub async fn maven_dependency_completion(
/// Adds an `<exclusion>` of `exclusion` to the declaration of the direct dependency
/// `dependency` of the Maven module `pom`, through the open document when there is one
/// (saved). Returns the declaration; nothing changes when it already excludes it.
#[command(trust = trusted)]
pub async fn maven_exclude_dependency(
host: &Host,
window: &str,
@@ -680,7 +630,7 @@ pub async fn maven_exclude_dependency(
files: vec![FileEdit::Edit { path: path.clone().into(), edits: vec![edit], version: None }],
..Default::default()
};
project.documents.apply_workspace_edit(&edit)?;
apply_workspace_edit(&project.documents, &edit)?;
}
Some(Exclusion::Present) => {}
None => return Err(IdeError::not_found(format!("{dependency} is not declared in {}", path.display()))),
@@ -787,7 +737,6 @@ fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id:
/// with `cancel_request(request)`. Diagnostics of `clear` (the files of the previous build)
/// are cleared first; the new messages are published as `build` diagnostics.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn build_run(
host: &Host,
window: &str,
@@ -886,19 +835,12 @@ pub async fn build_run(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok::<_, IdeError>(result)
Ok(result)
})
.await
.map_err(join_err);
host.end_request(request);
let outcome = result??;
// Maven generated sources (protobuf, gRPC) stay invisible to jdtls until the
// folders the build wrote are attached. An up-to-date build skips Maven and
// still needs this: the classes can already be on disk.
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
result?
}
/// Build › Compile File: compiles one Java source of a linked Maven module with
@@ -906,7 +848,6 @@ pub async fn build_run(
/// `cancel_request(request)`. Diagnostics of `clear` (the files of the previous
/// build) are cleared first; the new messages are published as `build`
/// diagnostics.
#[command(trust = trusted)]
pub async fn build_compile_file(
host: &Host,
window: &str,
@@ -935,16 +876,79 @@ pub async fn build_compile_file(
for (path, items) in compile::diagnostics(&result.messages) {
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
}
Ok::<_, IdeError>(result)
Ok(result)
})
.await
.map_err(join_err);
host.end_request(request);
let outcome = result??;
if outcome.system == ide_build::compile::BuildSystem::Maven {
project.lsp.sync_maven_generated_sources(&project.root).await;
}
Ok(outcome)
result?
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("build_model", |c| async move { build_model(&c.host, &c.window).await });
d.add("gradle_link_projects", |c| async move { gradle_link_projects(&c.host, &c.window, c.arg("paths")?).await });
d.add(
"gradle_unlink_projects",
|c| async move { gradle_unlink_projects(&c.host, &c.window, c.arg("paths")?).await },
);
d.add("build_sync", |c| async move {
build_sync(
&c.host,
&c.window,
c.arg("tool")?,
c.arg("request")?,
c.arg("offline")?,
c.arg("profiles")?,
c.arg("buildDir")?,
c.sender("onProgress")?,
)
.await
});
d.add("gradle_published_catalog", |c| async move {
gradle_published_catalog(&c.host, &c.window, c.arg("coordinates")?).await
});
d.add("gradle_dependencies", |c| async move {
gradle_dependencies(
&c.host,
&c.window,
c.arg("gradlePath")?,
c.arg("configuration")?,
c.arg("offline")?,
c.arg("request")?,
c.arg("buildDir")?,
)
.await
});
d.add("maven_dependency_declaration", |c| async move {
maven_dependency_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?).await
});
d.add("maven_goto_declaration", |c| async move {
maven_goto_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("pos")?).await
});
d.add("maven_dependency_completion", |c| async move {
maven_dependency_completion(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
d.add("maven_exclude_dependency", |c| async move {
maven_exclude_dependency(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?, c.arg("exclusion")?).await
});
d.add("build_run", |c| async move {
build_run(
&c.host,
&c.window,
c.arg("kind")?,
c.arg("file")?,
c.arg("cmake")?,
c.arg("request")?,
c.arg("clear")?,
c.sender("onEvent")?,
)
.await
});
d.add("build_compile_file", |c| async move {
build_compile_file(&c.host, &c.window, c.arg("file")?, c.arg("request")?, c.arg("clear")?, c.sender("onEvent")?)
.await
});
}
#[cfg(test)]
@@ -1271,19 +1275,3 @@ mod maven_completion_tests {
host.close_project("main");
}
}
ide_command::domain!(
build:
build_compile_file,
build_model,
build_run,
build_sync,
gradle_dependencies,
gradle_link_projects,
gradle_published_catalog,
gradle_unlink_projects,
maven_dependency_completion,
maven_dependency_declaration,
maven_exclude_dependency,
maven_goto_declaration,
);
+14 -11
Переглянути файл
@@ -1,6 +1,6 @@
//! Raw file bytes for the image viewer and hex view (see `ide_vfs::bytes`).
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use crate::ops::doc::blocking;
use ide_core::IdeResult;
@@ -8,24 +8,27 @@ use ide_vfs::{ByteRange, FileProbe};
use std::path::PathBuf;
/// Size and text/binary classification, from the file's head only.
#[command(trust = always)]
pub async fn fs_probe(path: PathBuf) -> IdeResult<FileProbe> {
pub async fn fs_probe(_host: &Host, _window: &str, path: PathBuf) -> IdeResult<FileProbe> {
blocking(move || ide_vfs::probe(&path)).await
}
/// Up to `len` bytes from `offset` (capped per call), base64-encoded.
#[command(trust = always)]
pub async fn fs_read_range(path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
pub async fn fs_read_range(_host: &Host, _window: &str, path: PathBuf, offset: u64, len: u32) -> IdeResult<ByteRange> {
blocking(move || ide_vfs::read_range(&path, offset, len)).await
}
/// An image file as a `data:` URL.
#[command(trust = always)]
pub async fn fs_read_image(host: &Host, path: PathBuf) -> IdeResult<String> {
// A network path is read only from a share an open project is on: the path may come from
// Markdown, and opening a share signs in to its server.
/// An image file as a `data:` URL. A network path is read only from a share an open project is
/// on: the path may come from Markdown, and opening a share signs in to its server.
pub async fn fs_read_image(host: &Host, _window: &str, path: PathBuf) -> IdeResult<String> {
let opened: Vec<PathBuf> = host.projects().iter().map(|project| project.root.clone()).collect();
blocking(move || ide_vfs::read_data_url(&path, &opened)).await
}
ide_command::domain!(bytes: fs_probe, fs_read_image, fs_read_range);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("fs_probe", |c| async move { fs_probe(&c.host, &c.window, c.arg("path")?).await });
d.add("fs_read_range", |c| async move {
fs_read_range(&c.host, &c.window, c.arg("path")?, c.arg("offset")?, c.arg("len")?).await
});
d.add("fs_read_image", |c| async move { fs_read_image(&c.host, &c.window, c.arg("path")?).await });
}
+8 -7
Переглянути файл
@@ -1,6 +1,6 @@
//! Run with Coverage: launch plans and coverage reports.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, IpcPath};
use ide_coverage::{CoveragePrepared, CoverageReportSpec, CoverageSuite};
@@ -15,7 +15,6 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
/// How to run `config` with coverage: the command to launch and where its report will be,
/// or which tool is missing.
#[command(trust = trusted)]
pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> IdeResult<CoveragePrepared> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -28,19 +27,21 @@ pub async fn coverage_prepare(host: &Host, window: &str, config: RunConfig) -> I
}
/// Reads the report a coverage run left behind.
#[command(trust = trusted)]
pub async fn coverage_collect(host: &Host, window: &str, report: CoverageReportSpec) -> IdeResult<CoverageSuite> {
host.require_trust(window)?;
blocking(move || ide_coverage::collect(&report)).await
}
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile or JaCoCo XML,
/// Reads a report collected elsewhere (CI): lcov, a Go cover profile, JaCoCo XML or a SimpleCov resultset,
/// with paths mapped into this project.
#[command(trust = always)]
pub async fn coverage_import(host: &Host, window: &str, path: IpcPath) -> IdeResult<CoverageSuite> {
// Also reads a SimpleCov resultset.
let root = host.project(window)?.root.clone();
blocking(move || ide_coverage::import(&path, &root)).await
}
ide_command::domain!(coverage: coverage_collect, coverage_import, coverage_prepare);
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("coverage_prepare", |c| async move { coverage_prepare(&c.host, &c.window, c.arg("config")?).await });
d.add("coverage_collect", |c| async move { coverage_collect(&c.host, &c.window, c.arg("report")?).await });
d.add("coverage_import", |c| async move { coverage_import(&c.host, &c.window, c.arg("path")?).await });
}
+293 -267
Переглянути файл
@@ -3,7 +3,7 @@
//! shell: its path comes from a local save dialog, so the export must land
//! on the user's machine, not the side the project runs on.
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
use ide_db::split::SqlStatement;
use ide_db::{
@@ -24,15 +24,172 @@ pub struct StatementOutcome {
pub error: Option<String>,
}
#[command(trust = trusted)]
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
// The data sources configured for the project (the tree's roots).
pub(crate) fn register(d: &mut Dispatcher) {
d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
d.add("db_save_sources", |c| async move {
let sources = c.arg("sources")?;
save_sources(&c.host, &c.window, sources).await
});
d.add("db_set_password", |c| async move {
let (id, password, save) =
(c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
set_password(&c.host, &c.window, &id, password, save).await
});
d.add("db_test", |c| async move {
let (source, password, ssh_secret) = (
c.arg::<DataSource>("source")?,
c.arg::<Option<String>>("password")?,
c.arg::<Option<String>>("sshSecret")?,
);
test(&c.host, &c.window, source, password, ssh_secret).await
});
d.add("db_test_tunnel", |c| async move {
let (source, ssh_secret) = (c.arg::<DataSource>("source")?, c.arg::<Option<String>>("sshSecret")?);
test_tunnel(&c.host, &c.window, source, ssh_secret).await
});
d.add("db_set_ssh_secret", |c| async move {
let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
set_ssh_secret(&c.host, &c.window, &id, secret, save).await
});
d.add("db_trust_ssh_host", |c| async move {
let id = c.arg::<String>("id")?;
trust_ssh_host(&c.host, &c.window, &id).await
});
d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
d.add("db_connect", |c| async move {
let id = c.arg::<String>("id")?;
connect(&c.host, &c.window, &id).await
});
d.add("db_set_manual_commit", |c| async move {
let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
set_manual_commit(&c.host, &c.window, &id, manual).await
});
d.add("db_finish_transaction", |c| async move {
let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
finish_transaction(&c.host, &c.window, &id, commit).await
});
d.add("db_disconnect", |c| async move {
let id = c.arg::<String>("id")?;
disconnect(&c.host, &c.window, &id).await
});
d.add("db_databases", |c| async move {
let id = c.arg::<String>("id")?;
databases(&c.host, &c.window, &id).await
});
d.add("db_database_catalog", |c| async move {
let (id, database) = (c.arg::<String>("id")?, c.arg::<String>("database")?);
database_catalog(&c.host, &c.window, &id, &database).await
});
d.add("db_saved_catalog", |c| async move {
let id = c.arg::<String>("id")?;
saved_catalog(&c.host, &c.window, &id).await
});
d.add("db_retain_catalog", |c| async move {
let (id, databases) = (c.arg::<String>("id")?, c.arg::<Vec<String>>("databases")?);
retain_catalog(&c.host, &c.window, &id, databases).await
});
d.add("db_session_context", |c| async move {
let id = c.arg::<String>("id")?;
session_context(&c.host, &c.window, &id).await
});
d.add("db_schemas", |c| async move {
let id = c.arg::<String>("id")?;
schemas(&c.host, &c.window, &id).await
});
d.add("db_tables", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
tables(&c.host, &c.window, &id, &schema).await
});
d.add("db_table_details", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
table_details(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_ddl", |c| async move {
let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
ddl(&c.host, &c.window, &id, &schema, &table).await
});
d.add("db_schema_objects", |c| async move {
let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
schema_objects(&c.host, &c.window, &id, &schema).await
});
d.add("db_object_ddl", |c| async move {
let (id, schema, kind, name) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<DbObjectKind>("kind")?,
c.arg::<String>("name")?,
);
object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
});
d.add("db_explain", |c| async move {
let (request, id, statement) =
(c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
let schema = c.arg::<Option<String>>("schema")?;
explain(&c.host, &c.window, request, &id, &statement, schema.as_deref()).await
});
d.add("db_history", |c| async move {
let id = c.arg::<String>("id")?;
history(&c.host, &c.window, &id).await
});
d.add("db_remove_history", |c| async move {
let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
remove_history(&c.host, &c.window, &id, texts).await
});
d.add("db_completion", |c| async move {
let id = c.arg::<String>("id")?;
completion(&c.host, &c.window, &id).await
});
d.add("db_statements", |c| async move {
let (id, text, from, to) =
(c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
statements(&c.host, &c.window, &id, &text, from, to)
});
d.add("db_execute", |c| async move {
let (request, id, statements, skip, max_rows) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<Vec<SqlStatement>>("statements")?,
c.arg::<Option<u32>>("skip")?.unwrap_or(0),
c.arg::<u32>("maxRows")?,
);
let schema = c.arg::<Option<String>>("schema")?;
execute(&c.host, &c.window, request, &id, statements, skip, max_rows, schema.as_deref()).await
});
d.add("db_table_page", |c| async move {
let (request, id, schema, table) = (
c.arg::<RequestId>("request")?,
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
);
let (filter, sort, offset, limit) = (
c.arg::<Option<String>>("filter")?,
c.arg::<Vec<SortKey>>("sort")?,
c.arg::<u32>("offset")?,
c.arg::<u32>("limit")?,
);
table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
});
d.add("db_apply_edits", |c| async move {
let (id, schema, table, edits) = (
c.arg::<String>("id")?,
c.arg::<String>("schema")?,
c.arg::<String>("table")?,
c.arg::<Vec<DbRowEdit>>("edits")?,
);
apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
});
d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
d.add("db_consoles", |c| async move { consoles(&c.host, &c.arg::<String>("id")?, c.arg("create")?) });
}
/// The data sources configured for the project (the tree's roots).
pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
host.project(window)?.db.sources()
}
#[command(trust = trusted)]
pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
// Replaces the project's data sources with `sources`.
/// Replaces the project's data sources with `sources`.
pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.save_sources(sources).await?;
let root = host.project(window)?.root.clone();
@@ -42,279 +199,222 @@ pub async fn db_save_sources(host: &Host, window: &str, sources: Vec<DataSource>
Ok(())
}
#[command(trust = trusted)]
pub async fn db_set_password(
host: &Host,
window: &str,
id: String,
password: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the password of data source `id` for the session, and in the OS
// saved passwords when `save` (`None` forgets it).
/// Remembers the password of data source `id` for the session, and in the OS
/// saved passwords when `save` (`None` forgets it).
pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_password(&id, password, save).await
db.set_password(id, password, save).await
}
#[command(trust = trusted)]
pub async fn db_test(
/// Test Connection: connects with unsaved settings and returns the server version.
pub async fn test(
host: &Host,
window: &str,
source: DataSource,
password: Option<String>,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Test Connection: connects with unsaved settings and returns the server version.
let db = host.project(window)?.db.clone();
db.test(&source, password, ssh_secret).await
}
/// Data Source › SSH/SSL › Test SSH Tunnel.
#[command(trust = trusted)]
pub async fn db_test_tunnel(
/// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
pub async fn test_tunnel(
host: &Host,
window: &str,
source: DataSource,
ssh_secret: Option<String>,
) -> IdeResult<String> {
// Checks the SSH tunnel of `source` alone: SSH login and the SSH host reaching the database.
let db = host.project(window)?.db.clone();
db.test_tunnel(&source, ssh_secret).await
}
#[command(trust = trusted)]
pub async fn db_set_ssh_secret(
host: &Host,
window: &str,
id: String,
secret: Option<String>,
save: bool,
) -> IdeResult<()> {
// Remembers the SSH password / key passphrase of a data source (see `db_set_password`).
/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_ssh_secret(&id, secret, save).await
db.set_ssh_secret(id, secret, save).await
}
#[command(trust = trusted)]
pub async fn db_trust_ssh_host(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Trusts the SSH host key that made the last connection of `id` fail with
// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
/// Trusts the SSH host key that made the last connection of `id` fail with
/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.trust_ssh_host(&id).await
db.trust_ssh_host(id).await
}
#[command(trust = trusted)]
pub fn db_connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
// The data sources with an open connection.
/// The data sources with an open connection.
pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
Ok(host.project(window)?.db.connected())
}
#[command(trust = trusted)]
pub async fn db_connect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Connects (fails with `permissionDenied` when the password is missing or wrong).
/// Connects (fails with `permissionDenied` when the password is missing or wrong).
pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.pool(&id).await.map(|_| ())
db.pool(id).await.map(|_| ())
}
#[command(trust = trusted)]
pub async fn db_set_manual_commit(host: &Host, window: &str, id: String, manual: bool) -> IdeResult<()> {
// Switches a data source between auto-commit and manual commit (leaving
// manual mode rolls back what was not committed).
/// Switches a data source between auto-commit and manual commit (leaving
/// manual mode rolls back what was not committed).
pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.set_manual_commit(&id, manual).await
db.set_manual_commit(id, manual).await
}
#[command(trust = trusted)]
pub async fn db_finish_transaction(host: &Host, window: &str, id: String, commit: bool) -> IdeResult<()> {
// Commits or rolls back the open transaction of a manual-commit data source.
/// Commits or rolls back the open transaction of a manual-commit data source.
pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.finish_transaction(&id, commit).await
db.finish_transaction(id, commit).await
}
#[command(trust = trusted)]
pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<()> {
// Closes the connection of data source `id`.
/// Closes the connection of data source `id`.
pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.disconnect(&id).await;
db.disconnect(id).await;
Ok(())
}
#[command(trust = trusted)]
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
let db = host.project(window)?.db.clone();
db.databases(&id).await
db.databases(id).await
}
#[command(trust = trusted)]
pub async fn db_database_catalog(
/// The schemas of `database` of Snowflake data source `id` with their tables and views.
pub async fn database_catalog(
host: &Host,
window: &str,
id: String,
database: String,
id: &str,
database: &str,
) -> IdeResult<Vec<ide_db::CatalogSchema>> {
// The schemas of `database` of Snowflake data source `id` with their tables and views.
let db = host.project(window)?.db.clone();
db.database_catalog(&id, &database).await
db.database_catalog(id, database).await
}
#[command(trust = trusted)]
pub async fn db_saved_catalog(host: &Host, window: &str, id: String) -> IdeResult<Option<ide_db::SourceCatalog>> {
// What earlier introspection of data source `id` saved; the data source is not connected to.
/// What earlier introspection of data source `id` saved; the data source is not connected to.
pub async fn saved_catalog(host: &Host, window: &str, id: &str) -> IdeResult<Option<ide_db::SourceCatalog>> {
let db = host.project(window)?.db.clone();
db.saved_catalog(&id).await
db.saved_catalog(id).await
}
#[command(trust = trusted)]
pub async fn db_retain_catalog(host: &Host, window: &str, id: String, databases: Vec<String>) -> IdeResult<()> {
// Drops the saved databases of data source `id` that are not in `databases` any more.
/// Drops the saved databases of data source `id` that are not in `databases` any more.
pub async fn retain_catalog(host: &Host, window: &str, id: &str, databases: Vec<String>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.retain_catalog(&id, databases).await
db.retain_catalog(id, databases).await
}
#[command(trust = trusted)]
pub async fn db_session_context(host: &Host, window: &str, id: String) -> IdeResult<ide_db::SessionContext> {
// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
/// The warehouse and role of the Snowflake session of data source `id`, and what it may switch to.
pub async fn session_context(host: &Host, window: &str, id: &str) -> IdeResult<ide_db::SessionContext> {
let db = host.project(window)?.db.clone();
db.session_context(&id).await
db.session_context(id).await
}
#[command(trust = trusted)]
pub async fn db_schemas(host: &Host, window: &str, id: String) -> IdeResult<Vec<String>> {
// The schemas of data source `id`.
/// The schemas of data source `id`.
pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
let db = host.project(window)?.db.clone();
db.schemas(&id).await
db.schemas(id).await
}
#[command(trust = trusted)]
pub async fn db_tables(host: &Host, window: &str, id: String, schema: String) -> IdeResult<Vec<TableInfo>> {
// The tables and views of `schema`.
/// The tables and views of `schema`.
pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
let db = host.project(window)?.db.clone();
db.tables(&id, &schema).await
db.tables(id, schema).await
}
#[command(trust = trusted)]
pub async fn db_table_details(
/// Columns, keys and indexes of `table`.
pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
let db = host.project(window)?.db.clone();
db.table_details(id, schema, table).await
}
/// The DDL of table or view `table` (Go to DDL, Generate DDL).
pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
let db = host.project(window)?.db.clone();
db.ddl(id, schema, table).await
}
/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
let db = host.project(window)?.db.clone();
db.schema_objects(id, schema).await
}
/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
pub async fn object_ddl(
host: &Host,
window: &str,
id: String,
schema: String,
table: String,
) -> IdeResult<TableDetails> {
// Columns, keys and indexes of `table`.
let db = host.project(window)?.db.clone();
db.table_details(&id, &schema, &table).await
}
#[command(trust = trusted)]
pub async fn db_ddl(host: &Host, window: &str, id: String, schema: String, table: String) -> IdeResult<String> {
// The DDL of table or view `table` (Go to DDL, Generate DDL).
let db = host.project(window)?.db.clone();
db.ddl(&id, &schema, &table).await
}
#[command(trust = trusted)]
pub async fn db_schema_objects(host: &Host, window: &str, id: String, schema: String) -> IdeResult<SchemaObjects> {
// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
let db = host.project(window)?.db.clone();
db.schema_objects(&id, &schema).await
}
#[command(trust = trusted)]
pub async fn db_object_ddl(
host: &Host,
window: &str,
id: String,
schema: String,
id: &str,
schema: &str,
kind: DbObjectKind,
name: String,
name: &str,
) -> IdeResult<String> {
// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
let db = host.project(window)?.db.clone();
db.object_ddl(&id, &schema, kind, &name).await
db.object_ddl(id, schema, kind, name).await
}
#[command(trust = trusted)]
pub async fn db_explain(
/// Explain Plan: the execution plan of `statement` on `id`, without running it.
pub async fn explain(
host: &Host,
window: &str,
request: RequestId,
id: String,
statement: String,
schema: Option<String>,
id: &str,
statement: &str,
schema: Option<&str>,
) -> IdeResult<Vec<PlanNode>> {
// Explain Plan: the execution plan of `statement` on `id`, without running it.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.explain(&id, &statement, &cancel, schema.as_deref()).await;
let result = db.explain(id, statement, &cancel, schema).await;
host.end_request(request);
result
}
#[command(trust = trusted)]
pub async fn db_history(host: &Host, window: &str, id: String) -> IdeResult<Vec<HistoryEntry>> {
// The statements data source `id` ran, newest first (Browse Query History).
/// The statements data source `id` ran, newest first (Browse Query History).
pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
let db = host.project(window)?.db.clone();
db.history(&id).await
db.history(id).await
}
#[command(trust = trusted)]
pub async fn db_remove_history(host: &Host, window: &str, id: String, texts: Option<Vec<String>>) -> IdeResult<()> {
// Removes statements from the query history of `id` (`None`: all of them).
/// Removes statements from the query history of `id` (`None`: all of them).
pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
let db = host.project(window)?.db.clone();
db.remove_history(&id, texts).await
db.remove_history(id, texts).await
}
#[command(trust = trusted)]
pub async fn db_completion(host: &Host, window: &str, id: String) -> IdeResult<CompletionModel> {
// Tables, columns and foreign keys for SQL completion.
/// Tables, columns and foreign keys for SQL completion.
pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
let db = host.project(window)?.db.clone();
db.completion(&id).await
db.completion(id).await
}
#[command(trust = trusted)]
pub fn db_statements(
host: &Host,
window: &str,
id: String,
text: String,
from: u32,
to: u32,
) -> IdeResult<Vec<SqlStatement>> {
// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
let driver = host.project(window)?.db.source(&id)?.driver;
/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
let driver = host.project(window)?.db.source(id)?.driver;
Ok(if from < to {
ide_db::split::statements_in(&text, from, to, driver)
ide_db::split::statements_in(text, from, to, driver)
} else {
ide_db::split::statement_at(&text, from, driver).into_iter().collect()
ide_db::split::statement_at(text, from, driver).into_iter().collect()
})
}
/// Runs `statements` in order on data source `id`, stopping at the first
/// error. Each result reads past its first `skip` rows (a later page) and keeps
/// `max_rows`. `schema` is the console's active context: the connection running
/// each statement is put in it first. Cancel with `cancel_request(request)`.
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn db_execute(
pub async fn execute(
host: &Host,
window: &str,
request: RequestId,
id: String,
id: &str,
statements: Vec<SqlStatement>,
// Clients before pagination send no `skip`.
#[default] skip: u32,
skip: u32,
max_rows: u32,
schema: Option<String>,
schema: Option<&str>,
) -> IdeResult<Vec<StatementOutcome>> {
// Runs `statements` in order on data source `id`, stopping at the first
// error. Each result reads past its first `skip` rows (a later page) and keeps
// `max_rows`. `schema` is the console's active context: the connection running
// each statement is put in it first. Cancel with `cancel_request(request)`.
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let mut out = Vec::new();
for statement in statements {
match db
.execute_from(&id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema.as_deref())
.await
{
match db.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel, schema).await {
Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
host.end_request(request);
@@ -335,62 +435,57 @@ pub async fn db_execute(
Ok(out)
}
/// One page of the rows of `table` (the table editor).
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn db_table_page(
pub async fn table_page(
host: &Host,
window: &str,
request: RequestId,
id: String,
schema: String,
table: String,
id: &str,
schema: &str,
table: &str,
filter: Option<String>,
sort: Vec<SortKey>,
offset: u32,
limit: u32,
) -> IdeResult<TablePage> {
// One page of the rows of `table` (the table editor).
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db
.table_page(&id, &schema, &table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel)
.await;
let result =
db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
host.end_request(request);
result
}
#[command(trust = trusted)]
pub async fn db_apply_edits(
/// Submits the table editor's changes in one transaction; returns the rows changed.
pub async fn apply_edits(
host: &Host,
window: &str,
id: String,
schema: String,
table: String,
id: &str,
schema: &str,
table: &str,
edits: Vec<DbRowEdit>,
) -> IdeResult<f64> {
// Submits the table editor's changes in one transaction; returns the rows changed.
let db = host.project(window)?.db.clone();
Ok(db.apply_edits(&id, &schema, &table, &edits).await? as f64)
Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
}
#[command(trust = always)]
pub fn db_console_path(host: &Host, id: String) -> IdeResult<IpcPath> {
// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
// created on first use. Consoles are files of the project, so a remote
// window resolves it on the host the project runs on.
let file = console_dir(host, &id)?.join("console.sql");
/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
/// created on first use. Consoles are files of the project, so a remote
/// window resolves it on the host the project runs on.
pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
let file = console_dir(host, id)?.join("console.sql");
if !file.exists() {
std::fs::write(&file, "")?;
}
Ok(file.into())
}
/// The query consoles of data source `id`; `create` adds the next one first.
#[command(trust = always)]
pub fn db_consoles(host: &Host, id: String, create: bool) -> IdeResult<Vec<IpcPath>> {
// The default `console.sql`, then `console_1.sql`, `console_2.sql`… in order
// (`create`: DataGrip's New › Query Console).
let dir = console_dir(host, &id)?;
/// The query consoles of data source `id`: the default `console.sql`, then
/// `console_1.sql`, `console_2.sql`… in order. `create` adds the next one first
/// (DataGrip's New › Query Console).
pub fn consoles(host: &Host, id: &str, create: bool) -> IdeResult<Vec<IpcPath>> {
let dir = console_dir(host, id)?;
let default = dir.join("console.sql");
let mut numbered: Vec<(u32, PathBuf)> = std::fs::read_dir(&dir)?
.filter_map(|e| {
@@ -437,72 +532,3 @@ fn console_dir(host: &Host, id: &str) -> IdeResult<PathBuf> {
std::fs::create_dir_all(&dir)?;
Ok(dir)
}
/// Runs a client tool against target `id` until it exits or the request is cancelled.
/// Desktop only: the file paths come from local dialogs.
pub async fn run_tool(
host: &Host,
window: &str,
request: RequestId,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
on_output: impl FnMut(Vec<ide_db::tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.run_tool(id, executable, job, &cancel, on_output).await;
host.end_request(request);
result
}
pub fn tool_preview(
host: &Host,
window: &str,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
) -> IdeResult<String> {
host.project(window)?.db.tool_preview(id, executable, job)
}
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
host.project(window)?.db.server_version(id).await
}
ide_command::domain!(
db:
db_apply_edits,
db_completion,
db_connect,
db_connected,
db_console_path,
db_consoles,
db_database_catalog,
db_databases,
db_ddl,
db_disconnect,
db_execute,
db_explain,
db_finish_transaction,
db_history,
db_object_ddl,
db_remove_history,
db_retain_catalog,
db_save_sources,
db_saved_catalog,
db_schema_objects,
db_schemas,
db_session_context,
db_set_manual_commit,
db_set_password,
db_set_ssh_secret,
db_sources,
db_statements,
db_table_details,
db_table_page,
db_tables,
db_test,
db_test_tunnel,
db_trust_ssh_host,
);
+233 -212
Переглянути файл
@@ -4,13 +4,12 @@ mod kotlin_tests;
mod output;
use crate::Host;
use ide_command::command;
use crate::rpc::Dispatcher;
use ide_core::{DebugSessionId, IdeResult};
use ide_dap::*;
use std::path::PathBuf;
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
#[command(trust = trusted)]
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
host.require_trust(window)?;
let unity_pid = if config.adapter == "unity" {
@@ -32,8 +31,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
} else {
None
};
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
let config = add_java_agents(config, &agents.options);
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -122,15 +119,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
let server_port = debug_server_port(&config);
let result = host.debugger.start_with(config, owner, custom).await;
flush_output();
if let Ok(id) = &result {
let sink = host.window_sink(label);
for note in &agents.notes {
sink.emit(ide_core::IdeEvent::Debug {
session: *id,
event: ide_core::event::DebugEvent::Output { category: "console".into(), output: format!("{note}\n") },
});
}
}
if result.is_err()
&& let Some(pid) = unity_pid
{
@@ -166,54 +154,10 @@ fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port: u16) {
let Ok(project) = host.project(window) else { return };
let Some(module) = project.lsp.java_debug_server_module(port) else { return };
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_jvm_inspector(session, inspector) {
tracing::debug!("jvm inspector for session {session:?}: {e}");
return;
}
let tracer = std::sync::Arc::new(ide_lsp::JdtStreamTracer::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_stream_tracer(session, tracer) {
tracing::debug!("stream tracer for session {session:?}: {e}");
}
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
fn is_jvm_launch(config: &LaunchConfig) -> bool {
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
if options.is_empty() || !is_jvm_launch(&config) {
return config;
}
let Some(serde_json::Value::Object(mut extra)) =
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok())
else {
return config;
};
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
let value = match extra.get(key) {
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
ide_run::java_agent::add_to_vm_args_text("", options).into()
}
Some(serde_json::Value::String(text)) => ide_run::java_agent::add_to_vm_args_text(text, options).into(),
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Array(_)) => {
let mut list: Vec<String> = extra
.get(key)
.and_then(serde_json::Value::as_array)
.map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
.unwrap_or_default();
ide_run::java_agent::add_to_vm_args(&mut list, options);
list.into()
}
Some(_) => return config,
};
extra.insert(key.into(), value);
config.extra_json = Some(serde_json::Value::Object(extra).to_string());
config
}
/// The JVM memory tab reads the class table over the attach socket, which only exists once the
@@ -273,38 +217,44 @@ fn match_java_debug_encoding(mut config: LaunchConfig, windows: bool) -> LaunchC
config
}
#[command(trust = trusted)]
pub async fn debug_set_breakpoints(
host: &Host,
_window: &str,
path: PathBuf,
breakpoints: Vec<Breakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_breakpoints(path, breakpoints).await
}
#[command(trust = trusted)]
pub async fn debug_threads(host: &Host, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
pub async fn debug_threads(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<Vec<ThreadInfo>> {
host.debugger.threads(session).await
}
#[command(trust = trusted)]
pub async fn debug_stack_trace(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<Vec<StackFrame>> {
pub async fn debug_stack_trace(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<Vec<StackFrame>> {
host.debugger.stack_trace(session, thread_id).await
}
#[command(trust = trusted)]
pub async fn debug_scopes(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
pub async fn debug_scopes(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<Vec<Scope>> {
host.debugger.scopes(session, frame_id).await
}
#[command(trust = trusted)]
pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
pub async fn debug_variables(
host: &Host,
_window: &str,
session: DebugSessionId,
reference: i64,
) -> IdeResult<Vec<Variable>> {
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -312,38 +262,40 @@ pub async fn debug_evaluate(
host.debugger.evaluate(session, frame_id, expression).await
}
#[command(trust = trusted)]
pub async fn debug_resume(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_resume(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.resume(session, thread_id).await
}
#[command(trust = trusted)]
pub async fn debug_pause(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_pause(host: &Host, _window: &str, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
host.debugger.pause(session, thread_id).await
}
/// Types `text` into the session's program (a `runInTerminal` program).
#[command(trust = trusted)]
pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String) -> IdeResult<()> {
pub async fn debug_send_input(host: &Host, _window: &str, session: DebugSessionId, text: String) -> IdeResult<()> {
host.debugger.send_input(session, &text)
}
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_reload(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_reload(session).await
}
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_hot_restart(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.hot_restart(session).await
}
#[command(trust = trusted)]
pub async fn debug_step(host: &Host, session: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
pub async fn debug_step(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
kind: StepKind,
) -> IdeResult<()> {
host.debugger.step(session, thread_id, kind).await
}
#[command(trust = trusted)]
pub async fn debug_run_to(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
path: PathBuf,
@@ -353,15 +305,14 @@ pub async fn debug_run_to(
host.debugger.run_to(session, thread_id, path, line, force).await
}
#[command(trust = always)]
pub async fn debug_stop(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.stop(session).await
}
/// Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16).
#[command(trust = trusted)]
/// The adapter's completions for an expression being typed in the frame `frame_id`.
pub async fn debug_completions(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
text: String,
@@ -372,9 +323,9 @@ pub async fn debug_completions(
}
/// Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`.
#[command(trust = trusted)]
pub async fn debug_evaluate_in(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: Option<i64>,
expression: String,
@@ -384,34 +335,31 @@ pub async fn debug_evaluate_in(
}
/// Last known verification states of a file's breakpoints (refetch on `breakpointsChanged`).
#[command(trust = trusted)]
pub fn debug_breakpoint_states(host: &Host, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
pub fn debug_breakpoint_states(host: &Host, _window: &str, path: PathBuf) -> IdeResult<Vec<BreakpointState>> {
Ok(host.debugger.breakpoint_states(&path))
}
/// This window's live sessions, including adapter-started child sessions.
#[command(trust = always)]
pub fn debug_sessions(host: &Host, window: &str) -> IdeResult<Vec<SessionInfo>> {
Ok(host.debugger.sessions(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub fn debug_exception_filters(host: &Host, window: &str) -> IdeResult<Vec<SessionExceptionFilters>> {
Ok(host.debugger.exception_filters(Some(host.owner_window(window))))
}
#[command(trust = trusted)]
pub async fn debug_set_exception_breakpoints(
host: &Host,
_window: &str,
choices: std::collections::BTreeMap<String, bool>,
) -> IdeResult<()> {
host.debugger.set_exception_breakpoints(choices).await
}
#[allow(clippy::too_many_arguments)]
#[command(trust = trusted)]
pub async fn debug_set_variable(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -423,24 +371,28 @@ pub async fn debug_set_variable(
}
/// Force Step Over: step over with every breakpoint suspended until the step ends.
#[command(trust = trusted)]
pub async fn debug_force_step_over(host: &Host, session: DebugSessionId, thread_id: i64) -> IdeResult<()> {
pub async fn debug_force_step_over(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
) -> IdeResult<()> {
host.debugger.force_step_over(session, thread_id).await
}
/// Smart Step Into: the calls on the current line of `frame_id`.
#[command(trust = trusted)]
pub async fn debug_step_in_targets(
host: &Host,
_window: &str,
session: DebugSessionId,
frame_id: i64,
) -> IdeResult<Vec<StepInTarget>> {
host.debugger.step_in_targets(session, frame_id).await
}
#[command(trust = trusted)]
pub async fn debug_step_in_target(
host: &Host,
_window: &str,
session: DebugSessionId,
thread_id: i64,
target_id: i64,
@@ -449,15 +401,13 @@ pub async fn debug_step_in_target(
}
/// Reset Frame (Drop Frame).
#[command(trust = trusted)]
pub async fn debug_restart_frame(host: &Host, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
pub async fn debug_restart_frame(host: &Host, _window: &str, session: DebugSessionId, frame_id: i64) -> IdeResult<()> {
host.debugger.restart_frame(session, frame_id).await
}
/// Breakpoints of a debugged page on DOM events and on requests (js-debug).
#[command(trust = trusted)]
pub async fn debug_js_custom_breakpoints(
host: &Host,
_window: &str,
session: DebugSessionId,
ids: Vec<String>,
xhr: Vec<String>,
@@ -465,65 +415,61 @@ pub async fn debug_js_custom_breakpoints(
host.debugger.js_set_custom_breakpoints(session, ids, xhr).await
}
/// The responses a debugged page gets in place of the server's, by a part of the URL; none
/// switches the replacing off.
#[command(trust = trusted)]
pub async fn debug_js_response_overrides(
host: &Host,
_window: &str,
session: DebugSessionId,
rules: Vec<ide_dap::JsResponseRule>,
) -> IdeResult<()> {
host.debugger.js_set_response_overrides(session, rules).await
}
/// The body of a response a debugged page received.
#[command(trust = trusted)]
pub async fn debug_js_response_body(
host: &Host,
_window: &str,
session: DebugSessionId,
request_id: String,
) -> IdeResult<ide_dap::JsResponseBody> {
host.debugger.js_response_body(session, request_id).await
}
/// Starts recording a debugged page's CPU profile.
#[command(trust = trusted)]
pub async fn debug_js_start_profile(host: &Host, session: DebugSessionId) -> IdeResult<()> {
pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
host.debugger.js_start_profile(session).await
}
/// Ends the recording: a directory holding the profile as `page.cpuprofile`.
#[command(trust = trusted)]
pub async fn debug_js_stop_profile(host: &Host, session: DebugSessionId) -> IdeResult<ide_core::IpcPath> {
pub async fn debug_js_stop_profile(
host: &Host,
_window: &str,
session: DebugSessionId,
) -> IdeResult<ide_core::IpcPath> {
host.debugger.js_stop_profile(session).await.map(Into::into)
}
#[command(trust = trusted)]
pub fn debug_capabilities(host: &Host, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
host.debugger.capabilities(session)
}
/// Method breakpoints (all files); states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_function_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<FunctionBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_function_breakpoints(breakpoints).await
}
/// Field watchpoints; states aligned with `breakpoints`.
#[command(trust = trusted)]
pub async fn debug_set_data_breakpoints(
host: &Host,
_window: &str,
breakpoints: Vec<DataBreakpoint>,
) -> IdeResult<Vec<BreakpointState>> {
host.debugger.set_data_breakpoints(breakpoints).await
}
#[command(trust = trusted)]
pub async fn debug_data_breakpoint_info(
host: &Host,
_window: &str,
session: DebugSessionId,
container: i64,
name: String,
@@ -533,23 +479,20 @@ pub async fn debug_data_breakpoint_info(
}
/// Attach to Process: the user's processes a debugger can attach to.
#[command(trust = always)]
pub async fn debug_attachable_processes() -> IdeResult<Vec<attach::AttachableProcess>> {
pub async fn debug_attachable_processes(_host: &Host, _window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
tokio::task::spawn_blocking(attach::attachable_processes)
.await
.map_err(|e| ide_core::IdeError::internal(format!("listing processes failed: {e}")))?
}
/// A loopback port that is free right now, for a debug agent the launch line starts.
#[command(trust = trusted)]
/// A loopback port that is free right now, for a debug agent the launch line starts
/// (`address=127.0.0.1:<port>`) — used when its "Listening for transport" line never reaches
/// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
// `address=127.0.0.1:<port>` — used when its "Listening for transport" line never reaches
// the console (a Surefire fork holds it until the tests run, which `suspend=y` prevents).
host.require_trust(window)?;
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
}
#[command(trust = trusted)]
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
host.require_trust(window)?;
let project = host.project(window)?;
@@ -563,29 +506,26 @@ pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<a
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
#[command(trust = trusted)]
pub async fn debug_listen_for_jvm(
ide: &Host,
host: &Host,
window: &str,
request: ide_core::RequestId,
host: String,
jvm_host: String,
port: u16,
) -> IdeResult<u16> {
ide.require_trust(window)?;
let token = ide.begin_request(request);
let result = jdwp::listen_for_jvm(&host, port, token).await;
ide.end_request(request);
host.require_trust(window)?;
let token = host.begin_request(request);
let result = jdwp::listen_for_jvm(&jvm_host, port, token).await;
host.end_request(request);
result
}
/// HotSwap (Reload Changed Classes) in a java-debug session.
#[command(trust = trusted)]
pub async fn debug_redefine_classes(host: &Host, session: DebugSessionId) -> IdeResult<HotSwapResult> {
pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<HotSwapResult> {
host.debugger.redefine_classes(session).await
}
/// The debuggee JVM's loaded classes (instances and shallow bytes), or why they cannot be read.
#[command(trust = trusted)]
/// The debuggee JVM's loaded classes, or why they cannot be read.
pub async fn debug_jvm_memory_classes(
host: &Host,
window: &str,
@@ -596,7 +536,6 @@ pub async fn debug_jvm_memory_classes(
}
/// Up to `limit` live instances of the class in the stopped JVM.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_instances(
host: &Host,
window: &str,
@@ -608,8 +547,7 @@ pub async fn debug_jvm_memory_instances(
host.debugger.jvm_memory_instances(session, class_name, limit).await
}
/// The fields (or array elements) of an instance in the stopped JVM.
#[command(trust = trusted)]
/// The fields (or array elements) of an instance listed by [`debug_jvm_memory_instances`].
pub async fn debug_jvm_memory_fields(
host: &Host,
window: &str,
@@ -621,7 +559,6 @@ pub async fn debug_jvm_memory_fields(
}
/// The objects that hold a reference to `object`; `limit` 0 selects the default.
#[command(trust = trusted)]
pub async fn debug_jvm_memory_referrers(
host: &Host,
window: &str,
@@ -633,6 +570,166 @@ pub async fn debug_jvm_memory_referrers(
host.debugger.jvm_memory_referrers(session, object, limit).await
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
d.add("debug_set_breakpoints", |c| async move {
debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
});
d.add("debug_threads", |c| async move { debug_threads(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_stack_trace", |c| async move {
debug_stack_trace(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add(
"debug_scopes",
|c| async move { debug_scopes(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await },
);
d.add("debug_variables", |c| async move {
debug_variables(&c.host, &c.window, c.arg("session")?, c.arg("reference")?).await
});
d.add("debug_evaluate", |c| async move {
debug_evaluate(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?, c.arg("expression")?).await
});
d.add(
"debug_resume",
|c| async move { debug_resume(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add(
"debug_pause",
|c| async move { debug_pause(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await },
);
d.add("debug_send_input", |c| async move {
debug_send_input(&c.host, &c.window, c.arg("session")?, c.arg("text")?).await
});
d.add("debug_step", |c| async move {
debug_step(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("kind")?).await
});
d.add("debug_run_to", |c| async move {
debug_run_to(
&c.host,
&c.window,
c.arg("session")?,
c.arg("threadId")?,
c.arg("path")?,
c.arg("line")?,
c.arg("force")?,
)
.await
});
d.add("debug_stop", |c| async move { debug_stop(&c.host, &c.window, c.arg("session")?).await });
d.add("debug_completions", |c| async move {
debug_completions(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("text")?,
c.arg("line")?,
c.arg("column")?,
)
.await
});
d.add("debug_evaluate_in", |c| async move {
debug_evaluate_in(
&c.host,
&c.window,
c.arg("session")?,
c.arg("frameId")?,
c.arg("expression")?,
c.arg("context")?,
)
.await
});
d.add("debug_breakpoint_states", |c| async move { debug_breakpoint_states(&c.host, &c.window, c.arg("path")?) });
d.add("debug_sessions", |c| async move { debug_sessions(&c.host, &c.window) });
d.add("debug_exception_filters", |c| async move { debug_exception_filters(&c.host, &c.window) });
d.add("debug_set_exception_breakpoints", |c| async move {
debug_set_exception_breakpoints(&c.host, &c.window, c.arg("choices")?).await
});
d.add("debug_set_variable", |c| async move {
debug_set_variable(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("evaluateName")?,
c.arg("frameId")?,
c.arg("value")?,
)
.await
});
d.add("debug_force_step_over", |c| async move {
debug_force_step_over(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?).await
});
d.add("debug_step_in_targets", |c| async move {
debug_step_in_targets(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_step_in_target", |c| async move {
debug_step_in_target(&c.host, &c.window, c.arg("session")?, c.arg("threadId")?, c.arg("targetId")?).await
});
d.add("debug_restart_frame", |c| async move {
debug_restart_frame(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
});
d.add("debug_capabilities", |c| async move { debug_capabilities(&c.host, &c.window, c.arg("session")?) });
d.add("debug_js_response_overrides", |c| async move {
debug_js_response_overrides(&c.host, &c.window, c.arg("session")?, c.arg("rules")?).await
});
d.add("debug_js_response_body", |c| async move {
debug_js_response_body(&c.host, &c.window, c.arg("session")?, c.arg("requestId")?).await
});
d.add("debug_js_custom_breakpoints", |c| async move {
debug_js_custom_breakpoints(&c.host, &c.window, c.arg("session")?, c.arg("ids")?, c.arg("xhr")?).await
});
d.add(
"debug_js_start_profile",
|c| async move { debug_js_start_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add(
"debug_js_stop_profile",
|c| async move { debug_js_stop_profile(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_set_function_breakpoints", |c| async move {
debug_set_function_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_set_data_breakpoints", |c| async move {
debug_set_data_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
});
d.add("debug_data_breakpoint_info", |c| async move {
debug_data_breakpoint_info(
&c.host,
&c.window,
c.arg("session")?,
c.arg("container")?,
c.arg("name")?,
c.arg("frameId")?,
)
.await
});
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
d.add("debug_listen_for_jvm", |c| async move {
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
});
d.add(
"debug_redefine_classes",
|c| async move { debug_redefine_classes(&c.host, &c.window, c.arg("session")?).await },
);
d.add("debug_jvm_memory_classes", |c| async move {
debug_jvm_memory_classes(&c.host, &c.window, c.arg("session")?).await
});
d.add("debug_jvm_memory_instances", |c| async move {
debug_jvm_memory_instances(&c.host, &c.window, c.arg("session")?, c.arg("className")?, c.arg("limit")?).await
});
d.add("debug_jvm_memory_fields", |c| async move {
debug_jvm_memory_fields(&c.host, &c.window, c.arg("session")?, c.arg("object")?).await
});
d.add("debug_jvm_memory_referrers", |c| async move {
debug_jvm_memory_referrers(&c.host, &c.window, c.arg("session")?, c.arg("object")?, c.arg("limit")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -716,36 +813,6 @@ mod tests {
);
}
#[test]
fn plugin_java_agents_join_the_vm_options_of_jvm_launches() {
let agent = "-javaagent:/my plugins/agent.jar=port=0".to_owned();
let options = std::slice::from_ref(&agent);
let field = |config: &LaunchConfig, key: &str| {
serde_json::from_str::<serde_json::Value>(config.extra_json.as_deref().unwrap()).unwrap()[key].clone()
};
let debugged =
add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})), options);
assert_eq!(vm_args(&debugged), "-Xmx1g \"-javaagent:/my plugins/agent.jar=port=0\"");
assert_eq!(add_java_agents(debugged.clone(), options).extra_json, debugged.extra_json, "not added twice");
let none = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": null})), options);
assert_eq!(vm_args(&none), "\"-javaagent:/my plugins/agent.jar=port=0\"");
let list = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]})), options);
assert_eq!(vm_args(&list), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({"vmArguments": ["-Xmx1g"]}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
for config in [
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
launch("debugpy", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})),
] {
assert_eq!(add_java_agents(config.clone(), options).extra_json, config.extra_json);
}
let config = launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"}));
assert_eq!(add_java_agents(config.clone(), &[]).extra_json, config.extra_json);
}
#[test]
fn debug_server_port_only_for_local_java_debug() {
let port = |adapter: &str, request: &str, extra| debug_server_port(&launch(adapter, request, extra));
@@ -766,49 +833,3 @@ mod tests {
}
}
}
ide_command::domain!(
debug:
debug_attachable_processes,
debug_breakpoint_states,
debug_capabilities,
debug_completions,
debug_data_breakpoint_info,
debug_evaluate,
debug_evaluate_in,
debug_exception_filters,
debug_force_step_over,
debug_free_port,
debug_js_custom_breakpoints,
debug_js_response_body,
debug_js_response_overrides,
debug_js_start_profile,
debug_js_stop_profile,
debug_jvm_memory_classes,
debug_jvm_memory_fields,
debug_jvm_memory_instances,
debug_jvm_memory_referrers,
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_restart_frame,
debug_resume,
debug_run_to,
debug_scopes,
debug_send_input,
debug_sessions,
debug_set_breakpoints,
debug_set_data_breakpoints,
debug_set_exception_breakpoints,
debug_set_function_breakpoints,
debug_set_variable,
debug_stack_trace,
debug_start,
debug_step,
debug_step_in_target,
debug_step_in_targets,
debug_stop,
debug_threads,
debug_unity_processes,
debug_variables,
);
+10 -11
Переглянути файл
@@ -1,6 +1,5 @@
//! Repository version lookups for manifest inspections and completion.
use crate::Host;
use ide_command::command;
use crate::{Host, rpc::Dispatcher};
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo, go, maven, npm};
use std::collections::BTreeMap;
@@ -141,11 +140,8 @@ impl DependencyVersionSource for GoModules {
}
fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
let search = self
.env
.get("PATH")
.map(std::ffi::OsString::from)
.unwrap_or_else(|| ide_core::tool_path::search_path_in(&self.root));
let search =
self.env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(ide_core::tool_path::search_path);
let go = ide_core::tool_path::find_command("go", &search, &self.root)
.ok_or_else(|| IdeError::unavailable("Go SDK is unavailable"))?;
// A partially edited go.mod is often invalid. Query outside it while
@@ -197,7 +193,7 @@ fn go_source(project: &crate::Project, config_dir: &Path, path: &Path) -> IdeRes
Ok(GoModules { root, env })
}
#[command(trust = trusted)]
/// `offset` limits a completion request to its version string; inspections omit it.
pub async fn dependency_versions(
host: &Host,
window: &str,
@@ -205,7 +201,6 @@ pub async fn dependency_versions(
offset: Option<u32>,
request: RequestId,
) -> IdeResult<Vec<DependencyVersions>> {
// `offset` limits a completion request to its version string; inspections omit it.
let project = host.project(window)?;
let cache = host.dependency_versions.clone();
let config_dir = host.config_dir.clone();
@@ -254,6 +249,12 @@ pub async fn dependency_versions(
result
}
pub(crate) fn register(d: &mut Dispatcher) {
d.add("dependency_versions", |c| async move {
dependency_versions(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
});
}
#[cfg(test)]
mod tests {
use super::*;
@@ -360,5 +361,3 @@ mod tests {
host.close_project("main");
}
}
ide_command::domain!(dependencies: dependency_versions);
+108 -101
Переглянути файл
@@ -1,5 +1,4 @@
use crate::Host;
use ide_command::command;
use ide_core::{CancellationToken, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
use ide_remote::{DeployedPath, DeploymentCoverage, DeploymentRoot, SyncEntry, SyncStep, TransferReport};
use ide_ssh::{FsConnection, RemoteEntry};
@@ -32,204 +31,212 @@ fn local(paths: Vec<IpcPath>) -> Vec<PathBuf> {
paths.into_iter().map(|p| p.to_path_buf()).collect()
}
#[command(trust = always)]
pub async fn deploy_coverage(window: &str, host: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
// Eligible paths per server, without contacting any deployment host.
let project = host.project(window)?;
/// Eligible paths per server, without contacting any deployment host.
pub async fn deploy_coverage(window: &str, state: &Host, paths: Vec<IpcPath>) -> IdeResult<Vec<DeploymentCoverage>> {
let project = state.project(window)?;
Ok(ide_remote::coverage(&project.settings.effective(), &project.root, &local(paths)))
}
#[command(trust = trusted)]
/// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
pub async fn deploy_upload(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Tools › Deployment › Upload to…: files and folders to `server` (default server when `None`).
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Uploading", token.clone());
let r = host
let r = state
.remote
.upload(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Download from…: the remote counterparts of files and folders.
pub async fn deploy_download(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Download from…: the remote counterparts of files and folders.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = host
let r = state
.remote
.download(&project.settings.effective(), &project.root, server.as_deref(), &local(paths), token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Deletes the remote counterparts of files and folders.
pub async fn deploy_delete_remote(
window: &str,
host: &Host,
state: &Host,
paths: Vec<IpcPath>,
server: Option<String>,
) -> IdeResult<TransferReport> {
// Deletes the remote counterparts of files and folders.
let project = host.project(window)?;
host.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
let project = state.project(window)?;
state.remote.delete_remote(&project.settings.effective(), &project.root, server.as_deref(), &local(paths)).await
}
#[command(trust = trusted)]
/// Sync with Deployed: local and remote files under `path`, side by side.
pub async fn deploy_compare(
window: &str,
host: &Host,
state: &Host,
path: IpcPath,
server: Option<String>,
request: RequestId,
) -> IdeResult<Vec<SyncEntry>> {
// Sync with Deployed: local and remote files under `path`, side by side.
let project = host.project(window)?;
let token = host.begin_request(request);
let r = host.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
host.end_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let r = state.remote.compare(&project.settings.effective(), &project.root, server.as_deref(), &path, token).await;
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Applies the Sync with Deployed choices.
pub async fn deploy_sync(
window: &str,
host: &Host,
state: &Host,
steps: Vec<SyncStep>,
server: Option<String>,
request: RequestId,
) -> IdeResult<TransferReport> {
// Applies the Sync with Deployed choices.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Synchronizing", token.clone());
let r = host
let r = state
.remote
.sync(&project.settings.effective(), &project.root, server.as_deref(), &steps, token, &mut report)
.await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = trusted)]
/// Where `path` is deployed (remote path, web URL); `None` when not mapped.
pub async fn deploy_info(
window: &str,
host: &Host,
state: &Host,
path: IpcPath,
server: Option<String>,
) -> IdeResult<Option<DeployedPath>> {
// Where `path` is deployed (remote path, web URL); `None` when not mapped.
let project = host.project(window)?;
host.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
let project = state.project(window)?;
state.remote.deployed(&project.settings.effective(), &project.root, server.as_deref(), &path).await
}
#[command(trust = trusted)]
pub async fn deploy_server_root(window: &str, host: &Host, server: String) -> IdeResult<DeploymentRoot> {
// Remote Host tool window: the resolved server root and project mappings.
let project = host.project(window).ok();
let settings = project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| host.global_settings.effective());
host.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
/// Remote Host tool window: the resolved server root and project mappings.
pub async fn deploy_server_root(window: &str, state: &Host, server: String) -> IdeResult<DeploymentRoot> {
let project = state.project(window).ok();
let settings =
project.as_ref().map(|p| p.settings.effective()).unwrap_or_else(|| state.global_settings.effective());
state.remote.server_info(&settings, project.as_ref().map(|p| p.root.as_path()), &server).await
}
#[command(trust = always)]
pub async fn remote_list(host: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
// Entries of a folder on the selected filesystem (`~`: its home directory).
host.remote.list(&connection, &path).await
/// Entries of a folder on the selected filesystem (`~`: its home directory).
pub async fn remote_list(state: &Host, connection: FsConnection, path: String) -> IdeResult<Vec<RemoteEntry>> {
state.remote.list(&connection, &path).await
}
#[command(trust = always)]
pub async fn remote_open(host: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
// Opens a remote file for editing: a local copy, uploaded back on save.
Ok(host.remote.open_remote(&connection, &path).await?.into())
/// Opens a remote file for editing: a local copy, uploaded back on save.
pub async fn remote_open(state: &Host, connection: FsConnection, path: String) -> IdeResult<IpcPath> {
Ok(state.remote.open_remote(&connection, &path).await?.into())
}
#[command(trust = always)]
pub fn remote_of(host: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
// The filesystem connection and path a cached editing copy stands for.
host.remote.remote_of(&path)
/// The filesystem connection and path a cached editing copy stands for.
pub fn remote_of(state: &Host, path: IpcPath) -> Option<(FsConnection, String)> {
state.remote.remote_of(&path)
}
#[command(trust = trusted)]
pub async fn remote_delete(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_delete(&connection, &path).await
pub async fn remote_delete(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_delete(&connection, &path).await
}
#[command(trust = trusted)]
pub async fn remote_mkdir(host: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
host.remote.remote_mkdir(&connection, &path).await
pub async fn remote_mkdir(state: &Host, connection: FsConnection, path: String) -> IdeResult<()> {
state.remote.remote_mkdir(&connection, &path).await
}
#[command(trust = trusted)]
pub async fn remote_rename(host: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
host.remote.remote_rename(&connection, &from, &to).await
pub async fn remote_rename(state: &Host, connection: FsConnection, from: String, to: String) -> IdeResult<()> {
state.remote.remote_rename(&connection, &from, &to).await
}
#[command(trust = trusted)]
/// Remote Host › Download to…: remote files and folders into a local folder, each under its
/// own name.
pub async fn remote_download_into(
window: &str,
host: &Host,
state: &Host,
connection: FsConnection,
paths: Vec<String>,
target: IpcPath,
request: RequestId,
) -> IdeResult<TransferReport> {
// Remote Host › Download to…: remote files and folders into a local folder, each under its
// own name.
let project = host.project(window)?;
let token = host.begin_request(request);
let project = state.project(window)?;
let token = state.begin_request(request);
let (mut report, done) = progress(project.sink.clone(), "Downloading", token.clone());
let r = host.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
let r = state.remote.download_into(&connection, &paths, &target, &token, &mut report).await;
done();
host.end_request(request);
state.end_request(request);
r
}
#[command(trust = always)]
/// `password`: an FTP password typed in the settings but not applied yet.
pub async fn deploy_test_connection(
host: &Host,
state: &Host,
connection: FsConnection,
path: String,
password: Option<String>,
) -> IdeResult<()> {
// `password`: an FTP password typed in the settings but not applied yet.
host.remote.test_connection_with(&connection, &path, password).await
state.remote.test_connection_with(&connection, &path, password).await
}
ide_command::domain!(
deploy:
deploy_compare,
deploy_coverage,
deploy_delete_remote,
deploy_download,
deploy_info,
deploy_server_root,
deploy_sync,
deploy_test_connection,
deploy_upload,
remote_delete,
remote_download_into,
remote_list,
remote_mkdir,
remote_of,
remote_open,
remote_rename,
);
pub(crate) fn register(d: &mut crate::rpc::Dispatcher) {
d.add("deploy_coverage", |c| async move { deploy_coverage(&c.window, &c.host, c.arg("paths")?).await });
d.add("deploy_upload", |c| async move {
deploy_upload(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_download", |c| async move {
deploy_download(&c.window, &c.host, c.arg("paths")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_delete_remote", |c| async move {
deploy_delete_remote(&c.window, &c.host, c.arg("paths")?, c.arg("server")?).await
});
d.add("deploy_compare", |c| async move {
deploy_compare(&c.window, &c.host, c.arg("path")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_sync", |c| async move {
deploy_sync(&c.window, &c.host, c.arg("steps")?, c.arg("server")?, c.arg("request")?).await
});
d.add("deploy_info", |c| async move { deploy_info(&c.window, &c.host, c.arg("path")?, c.arg("server")?).await });
d.add("deploy_server_root", |c| async move { deploy_server_root(&c.window, &c.host, c.arg("server")?).await });
d.add("remote_list", |c| async move { remote_list(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_open", |c| async move { remote_open(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_of", |c| async move { Ok(remote_of(&c.host, c.arg("path")?)) });
d.add("remote_delete", |c| async move { remote_delete(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_mkdir", |c| async move { remote_mkdir(&c.host, c.arg("connection")?, c.arg("path")?).await });
d.add("remote_download_into", |c| async move {
remote_download_into(
&c.window,
&c.host,
c.arg("connection")?,
c.arg("paths")?,
c.arg("target")?,
c.arg("request")?,
)
.await
});
d.add("remote_rename", |c| async move {
remote_rename(&c.host, c.arg("connection")?, c.arg("from")?, c.arg("to")?).await
});
d.add("deploy_test_connection", |c| async move {
deploy_test_connection(&c.host, c.arg("connection")?, c.arg("path")?, c.arg("password")?).await
});
}
+19 -51
Переглянути файл
@@ -1,13 +1,9 @@
use crate::Host;
use ide_command::command;
use ide_core::{ChangeSet, DocId, IdeResult};
use ide_workspace::DocumentInfo;
use std::path::PathBuf;
/// Opens a document. Async: reading and decoding a large file must not block
/// the main thread (synchronous commands run on it).
#[command(trust = always)]
pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
pub async fn open(host: &Host, window: &str, path: PathBuf) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.open(&path)?;
@@ -20,30 +16,22 @@ pub async fn doc_open(host: &Host, window: &str, path: PathBuf) -> IdeResult<Doc
.await
}
#[command(trust = always)]
pub async fn doc_close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
blocking(move || {
project.documents.close(doc);
Ok(())
})
.await
pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
host.project(window)?.documents.close(doc);
Ok(())
}
/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
/// through `doc_save_as`, which turns it into a regular file document.
#[command(trust = always)]
pub async fn doc_open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
// `name` re-references an already minted buffer instead of creating one.
/// through [`save_as`], which turns it into a regular file document. `name`
/// re-references an already minted buffer instead of creating one.
pub async fn open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || project.documents.open_untitled(name.as_deref())).await
}
/// Save As for an untitled buffer: writes it to `path` and re-keys the buffer
/// (undo history and version are kept; the language is re-detected).
#[command(trust = always)]
pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
// LightEdit windows start watching the saved file's folder.
/// Save As for an untitled buffer ([`Documents::save_as`]); LightEdit windows
/// start watching the saved file's folder.
pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || {
let info = project.documents.save_as(doc, &path)?;
@@ -55,31 +43,25 @@ pub async fn doc_save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -
.await
}
/// Applies a CodeMirror change set; returns the new version. Rejects with
/// `outOfSync` when `base_version` is stale; the UI then calls `doc_snapshot`.
#[command(trust = always, desktop_body = async)]
pub async fn doc_edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
let project = host.project(window)?;
blocking(move || project.documents.edit(doc, base_version, changes)).await
/// Applies a CodeMirror change set; returns the new version (`outOfSync` when `base_version` is stale).
pub fn edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
host.project(window)?.documents.edit(doc, base_version, changes)
}
#[command(trust = always)]
pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
pub async fn save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save(doc)).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
#[command(trust = always)]
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
pub async fn save_all(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || project.documents.save_all()).await?;
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
}
#[command(trust = always)]
pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
// Recovers external changes missed by the project's file watchers.
/// Recovers external changes missed by the project's file watchers.
pub async fn sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
let project = host.project(window)?;
host.blocking(move || {
if project.settings.effective().files.sync_on_focus {
@@ -90,27 +72,13 @@ pub async fn doc_sync_from_disk(host: &Host, window: &str) -> IdeResult<()> {
.await
}
#[command(trust = always)]
pub async fn doc_snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
pub async fn snapshot(host: &Host, window: &str, doc: DocId) -> IdeResult<DocumentInfo> {
let project = host.project(window)?;
host.blocking(move || project.documents.snapshot(doc)).await
}
pub mod commands;
mod commands;
pub use commands::*;
#[cfg(test)]
mod tests;
ide_command::domain!(
doc:
doc_close,
doc_edit,
doc_open,
doc_open_untitled,
doc_save,
doc_save_all,
doc_save_as,
doc_snapshot,
doc_sync_from_disk,
);
Loaded 100 of 1196 files, more files were not shown because too many files have changed in this diff. Show more