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

...
Автор SHA1 Повідомлення Дата
时雨遥 53495fbc26 fix(terminal): tab spinner stops while an interactive program without a progress report waits for input (#3838)
Closes #3831

An interactive program is one long command to the shell, so OSC 133 C/D kept the tab spinning from launch to exit for programs that send no OSC 9;4 report (Claude Code, Codex). A running command that turned on bracketed paste or the alternate screen reads the keyboard itself; its tab now spins only while it keeps drawing (output at most 400 ms apart for 500 ms, until 1.5 s of silence; typing echo excluded). A progress report still decides when present, and plain commands spin from start to end as before.

Co-authored-by: StarryKira <[email protected]>
2026-11-17 04:37:15 +08:00
l0ng-ai 224099992a feat(python): create a Conda environment by name in conda's envs directory (#3839)
The Add Python Interpreter dialog asks for a Conda environment's name (the
project folder's by default) instead of a location. The backend runs
`conda create -n <name>` for a bare name, refuses a name conda already lists,
and finds the new prefix from `conda env list`; a path still creates the
environment at that prefix with `-p`.
2026-11-17 04:29:39 +08:00
l0ng-ai 0dafd649da fix(python): readable environment creation log and status refresh after creating one (#3837)
Tool output is shown as a terminal would show the line: backspaces erase
(conda's spinner), a carriage return rewrites the line (pip progress) and
ANSI sequences are dropped.

The interpreter status widget re-reads interpreters when one is created or
added in Settings. A conda environment lives outside the project, so no file
event announced it, and when the configured path was already set the widget
kept showing "Invalid interpreter" and an interpreter list without it.
2026-11-17 04:24:28 +08:00
l0ng-ai d2c5532ccb fix(completion): complete at every caret (#3836)
With several carets, picking a completion inserted it at the main caret only
and collapsed the selection. The item now goes in at each caret whose text
around it matches the main caret's (the typed prefix, and what a replacing
edit overwrites). Snippets go in as plain text with each caret at the first
stop. Items the server inserts itself (kotlin-lsp) keep the carets, and the
server's edit is repeated at the others when it lands.
2026-11-17 04:18:31 +08:00
l0ng-ai a03923f744 fix(fonts): editor popups and consoles follow the configured fonts (#3835)
- Completion, parameter info and hover docs render in a tooltip container
  outside the editor, which carries its theme classes but not its inline
  style, so they used the default mono font at 13px. The editor font
  variables are now also provided as a theme; completion rows grow with
  the font size.
- The Run and Debug consoles use the terminal's weights (the editor's main
  and bold weights when the terminal follows the editor font).
- "Show only monospaced fonts" is a setting shared by Editor › Font and
  Tools › Terminal instead of resetting every time the page opens.

Fixes #3621
2026-11-17 04:09:12 +08:00
Vadim LazukтаInf1mum 8668fdd731 fix(terminal): a program's OSC 9;4 progress report drives the tab spinner (#3833)
While a command runs, the terminal tab's spinner follows the program's own OSC 9;4 progress report: state 0 stops it while the command is still alive, states 1-4 keep it. Programs that never report progress behave as before. A non-shell command tab also clears its running marker when the process exits or fails to start.

Refs #3831

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 03:52:00 +08:00
Vadim LazukтаInf1mum 17e7b98cfc fix(e2e): size-check both close button svgs in findUsages-ui (#3834)
The Close Tab button now stacks idle and hovered icons, so the single-svg locator hit Playwright's strict mode. The spec checks every svg each toolbar button renders.

Closes #3828

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 03:46:36 +08:00
Bert Verhelstтаbertyhell 77e6679701 feat(ui): the frameless title bar follows the desktop's window button layout (#3817)
On Linux the frameless title bar reads the desktop's button layout (GTK decoration layout / GNOME button-layout) and places close, minimize and maximize on the left or right in that order; auxiliary windows such as Settings follow it. Other platforms and the default layout are unchanged. Verified on Ubuntu GNOME (Wayland) with left and right layouts.

Closes #3794

Co-authored-by: bertyhell <[email protected]>
2026-11-17 03:45:50 +08:00
Bert Verhelstтаbertyhell 5a0bd7d1fc feat(editor): rainbow brackets for generics and markup tags, with kind switches and 2–5 colours (#3832)
Rainbow brackets get per-kind switches (round, square, curly, and angle brackets and tags) and a palette length of 2–5 colours; defaults are unchanged. Angle brackets are coloured only inside syntax nodes a language definition names under [rainbow-brackets] (type argument/parameter lists for TypeScript/TSX, Java, Rust and C++; tags for HTML, XML, Vue, Svelte and JSX), so comparisons and shifts stay uncoloured. A kind switched off keeps the other brackets' depths. Colour schemes gain --syn-bracket-4/5; indent guides and sticky lines follow the palette length.

Closes #3769

Co-authored-by: bertyhell <[email protected]>
2026-11-17 03:41:02 +08:00
Bert Verhelstтаbertyhell e6daffae76 feat(plugins): read the Maven / Gradle dependency graph (API 1.10) (#3829)
Plugins had to run mvn dependency:tree / gradlew dependencies themselves or parse build files. A new build interface in wit/workspace.wit, build.dependencies(project, module), returns the graph the Dependency Analyzer has as a flat list of dependency-node records (group, artifact, version, scope, status, requested version, parent), each module a root, behind the low-risk build.read capability in trusted projects. Nothing is resolved by the call: Maven returns the trees cached by the last Reload (declared dependencies before one); Gradle dependency reports, which only lived in the frontend, are now saved per project and configuration in the build cache and dropped on a build-file change. Capped at 100,000 nodes per call. SDK: Project::build_dependencies with a mock; checked-in components rebuilt.

Closes #3715

Co-authored-by: bertyhell <[email protected]>
2026-11-17 03:29:39 +08:00
Bert Verhelstтаbertyhell 2b69d64055 feat(plugins): a granted plugin's Java agent joins Java run configurations (API 1.10) (#3830)
Plugins that instrument the user's application had no way to get a Java agent into the JVM the IDE starts. A [[contributes.javaAgents]] entry (one per plugin, a jar inside the package, optional single-line args, API ^1.10) derives the high-risk java.agent capability; granting it records the jar's blake3 hash, and every launch re-hashes the jar and leaves out a changed or missing one until approved again. For Application, Spring Boot and JAR Application run and debug, the host adds one -javaagent argument after the VM options (java-debug vmArgs, Kotlin vmArguments), never twice, and a shortened command line keeps it as its own argument. Remote projects and run targets get no agent, with one console line. Settings › Plugins shows the agent next to the permission.

Closes #3566

Co-authored-by: bertyhell <[email protected]>
2026-11-17 03:20:18 +08:00
Bruno Belloni 6c9556ef54 fix(welcome): list remote windows under Open Projects in the project widget (#3824)
Connecting a window to a remote host (WSL, SSH, Dev Container) closes its local project, and window_open_projects only looked up local projects, so remote windows never appeared under Open Projects. It now reports remote windows from their connection, with OpenProject.remote; the project widget keys them like their recent entry (remoteLocation) so they leave Recent Projects, and picking one focuses the connected window through openRecent.

Co-authored-by: brunobelloni <[email protected]>
2026-11-17 03:12:17 +08:00
Bert Verhelstтаbertyhell 64ee712401 feat(plugins): diffs with a missing side for added and deleted files (API 1.10) (#3827)
views.open-diff takes exactly two texts, so a plugin could not tell the IDE that a file does not exist on one side, and the diff drew an empty pane next to it. API 1.10 adds views.open-file-diff with a file-diff record whose left / right are option<string> (none: the file does not exist there; both none is invalid); the SDK adds host::open_file_diff with a mock, and web views may send null for a missing side. A missing side maps to the same absent text side the VCS diffs use, so the existing side shows alone. open-diff and content-diff are unchanged. The WIT package, ENGINE_VERSION and API_VERSION move to 1.10.0, with the checked-in components rebuilt.

Closes #3780

Co-authored-by: bertyhell <[email protected]>
2026-11-17 03:07:57 +08:00
Bert Verhelstтаbertyhell 0ff491cce8 fix(build): Maven reactor modules outside the project become content roots (#3825)
A Maven aggregator whose <modules> point outside the opened folder (<module>../service-a</module>) loaded those modules into the Maven model, but they were missing from the file tree, index, watchers and the Java server's workspace folders. Out-of-root reactor modules now go through maven_external_roots like linked POMs: they become content roots and jdtls import roots, outermost folder only. Only modules reachable from the project's own reactor count (including active profiles), only in a trusted project, and a folder that holds the project is skipped. A Maven reload refreshes the index scope. The POM walk is memoized on the reactor POMs' modification times and sizes.

Closes #3717

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:58:47 +08:00
Bert Verhelstтаbertyhell 4ce661ee1f feat(settings): option to open Settings in the project window instead of a new window (#3823)
New setting Appearance › UI Options › Open Settings in a separate window (appearance.settingsInSeparateWindow, desktop only, on by default). With it off, Settings…, Keymap…, Appearance… and Settings for New Projects… open the in-page Settings dialog in the project window, which opens instantly, instead of creating a native window on every open. A link to a Settings page now behaves the same in both modes: while the in-page dialog is open it switches the page, clears the search and keeps unapplied edits.

Closes #3797

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:52:55 +08:00
Bert Verhelstтаbertyhell 55e89eac1a feat(project-tree): Reformat Code on a directory or several selected files (#3822)
The Project view only ever passed one file to code.reformatFile. A directory or a multi-selection now opens a Reformat Code dialog (Include subdirectories, Optimize imports, File mask with ! excludes, Only VCS changed text); Run reformats and saves every matching file as one cancellable background task, and a single file still reformats straight away. The batch reuses Code Cleanup's per-file step through a shared runOverFiles runner; formatDocument accepts ranges for changed text and reports noFormatter, including when the file's formatter tool is not installed, so skipped files are named in the summary. Ignored, excluded, hidden, symlinked and binary entries are skipped.

Closes #3804

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:49:19 +08:00
Bert Verhelstтаbertyhell fcc8467657 fix(terminal): Windows path links keep their directories and drive (#3826)
The terminal's FILE_RE accepted only / as a separator and no drive prefix, so on Windows src\bin\main.rs:10:5, .\main.go:5:2, C:\p\web\index.js:3:7 or C:\p\Program.cs(10,5) got a link on the basename only, and openFileLink opened whichever same-named file it found first. The pattern now also accepts \ separators, a C:\ / C:/ drive and a .\ prefix, like the run console's pattern; embedded terminals and link highlighting share it.

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:46:01 +08:00
Bert Verhelstтаbertyhell 489dd408bb fix(editor): Markdown code fences highlight in their language (#3821)
Markdown came from @codemirror/language-data, which calls markdown() without codeLanguages, so fenced blocks had no language to nest. Markdown is now one of the editor's own modes: a fence's info string resolves through the editor's lookup (mode name or alias, then backend language id or extension), so a block gets the same patched mode as a file; unknown info strings stay plain. Block bodies carry data-language and the per-language colour scheme rules also match .cm-editor [data-language=X], so language colour changes apply inside blocks. @codemirror/lang-markdown (already in the lockfile via language-data) is now a direct dependency.

Closes #3808

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:45:11 +08:00
Bert Verhelstтаbertyhell 4010f61453 fix(project-view): ⌘D compares the selected files or folders instead of showing Git diffs (#3820)
Show Diff claimed ⌘D / Ctrl+D everywhere outside a text editor through its keyWhen, and dispatch runs a matching keyWhen before an action without one, while Compare With… was scoped to the Project view by when only. Compare With… now also claims the Project view by keyWhen, so the preset order decides there again: two files open Compare Files, two folders Compare Directories, one file or folder Compare With…. The shortcut and the context menu share one choice of comparison, and the menu shows the shortcut on Compare Files and Compare Directories.

Closes #3806

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:43:23 +08:00
Mr0Bread 00bbc474c0 fix(agents): discover per-model effort settings before the first prompt (#3807)
ACP discovery learned effort settings only for the session's default model, so picking another model before its first prompt lost the effort control. The shared catalog now discovers a selected model's missing settings in a short-lived ACP session (session/set_config_option, no prompt), tells unknown settings apart from verified no-effort models, shows loading, discards stale discoveries during rapid model changes, and keeps per-model failures and cooldowns separate. Idle-task model switches use the same discovery and keep the previous controls when it fails. Discovery errors keep their cause.

Closes #3789

Co-authored-by: Mr0Bread <[email protected]>
2026-11-17 02:40:13 +08:00
Bert Verhelstтаbertyhell 2f68c83bcd feat(editor): a Code Vision switch, toggle action and hint menu (#3815)
Code Vision could only be turned off one kind at a time. A master setting, editor.inlay.codeVision (Editor › Inlay Hints › Code Vision › Show Code Vision, on by default), hides usages, author and language-server lenses while keeping the per-kind choices; a Code Vision toggle action (editor.toggleCodeVision, no default shortcut) flips it; and a right-click on a hint offers Hide Usages / Hide Code Author for that hint, Hide Code Vision and Code Vision Settings…. Code Vision is kept untranslated as a product name in the catalog checks.

Closes #3785

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:36:56 +08:00
Bert Verhelstтаbertyhell 567e45f830 fix(vcs): the background incoming check fetches every repository (#3812)
With Explicitly check for incoming commits on remotes on, the background check fetched only the repository selected in the branch widget. It now fetches every repository in the window whose branch has an upstream, one after another, stopping when the project or setting changes or a user's fetch / pull / push starts. With auto, a failure stops the check for that repository only; always retries every time. The interval is a new setting, vcs.git.incomingCheckInterval (minutes, 1-1440, default 15).

Closes #3796

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:31:22 +08:00
Bert Verhelstтаbertyhell 245679cef8 fix(vcs): the inline blame label can be made not clickable (#3810)
The inline blame label was always a button that swallowed its events, so a click past the end of a line could open the commit instead of placing the caret. A new setting, vcs.git.inlineBlameClickable (Settings › Version Control › Git, on by default), makes the label plain text when off: no role, tab stop or handlers, and its events go to the editor. The uncommitted-changes label, which has no commit to open, now hands its events to the editor too. Open editors update without another git blame.

Closes #3802

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:27:28 +08:00
Bert Verhelstтаbertyhell 3f3ad03d7c fix(vcs): the Git Log changed-file list marks symbolic links (#3813)
The revision diffs behind the Git Log (vcs_commit_files, vcs_diff_revisions, vcs_commits_changes) returned only path and kind, dropping git mode 120000, so every link looked like a plain file. ChangedFile / RevisionChange now carry an optional link (dir / file / unresolved), resolved inside that revision's own tree, following links along the way; absolute, above-root, dangling and looping targets are unresolved, and a deleted link is described as it was before. vcs_diff_revisions parses git diff --raw instead of --name-status. Git Log rows draw the same link markers as the Project tree.

Closes #3777

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:23:28 +08:00
Bert Verhelstтаbertyhell 03ee687353 fix(vcs): diffs pick a file's language as its editor does (#3811)
Code shown outside an editor tab (diffs, merge editor, revision browser, previews of closed files) picked its language on the frontend from the file extension, while the editor uses the backend's detection, which also checks overrides, File Types patterns and the first line. A single resolver, languageDescriptionFor, now uses the open editor's mode when the file is open and otherwise asks the backend (doc_language, replacing doc_ui_mode) to detect it from the shown text's first line, or the open buffer / file on disk, falling back to the extension only when that fails.

Closes #3799

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:06:23 +08:00
Bert Verhelstтаbertyhell 2e9e2c1699 fix(editor): rainbow guides take the colour of their bracket block (#3814)
Rainbow indent guides were coloured by indentation depth and rainbow brackets by bracket nesting, with nothing linking the two. With both on, a guide now takes the colour of the bracket its block's opening line leaves open (BracketScanner.openAt, reusing the scanner's checkpoints); blocks without one (Python, YAML, continuation lines) keep the depth colour. Code lens rows copy their line's guide variables instead of rebuilding depth-only guides, and sticky lines keep their rainbow bracket colours.

Closes #3771

Co-authored-by: bertyhell <[email protected]>
2026-11-17 02:00:36 +08:00
Bert Verhelstтаbertyhell d84d8829c4 fix(vcs): branch pickers in the Git dialogs filter as you type (#3816)
Merge, Rebase (upstream and --onto), Pull's remote branch and New Worktree's checkout used plain non-searchable Selects, so repositories with hundreds of branches could only be scrolled. They now share a BranchSelect that is always searchable, and a searchable Select opens its list with the typed key as the query when a key is pressed on the closed trigger. The agents' base-branch picker is searchable too.

Closes #3788

Co-authored-by: bertyhell <[email protected]>
2026-11-17 01:58:49 +08:00
Bert Verhelstтаbertyhell 38dfa37c88 fix(run): Debug on a compiled single file stops the instance being debugged first (#3818)
Context launches of a compiled single file (Rust / C / C++ / Zig) built the binary and called debug.startConfig directly, skipping the single-instance check run.debugConfig applies, so a second Debug started another session. The check moved into a shared debugSingleInstance helper used by both paths: it asks before stopping the running and debugged instances, ignores a Debug while one is still preparing, and leaves parallel-run configurations alone.

Co-authored-by: bertyhell <[email protected]>
2026-11-17 01:57:14 +08:00
zhangdagouтаPLZY 447560e505 fix(editor): Back returns to a just-closed file or diff, and opening a file from a diff keeps the diff open (#3791)
Opening a declaration from a diff preview (Cmd/Ctrl-click, Jump to Source) closed the diff, and Back could not return to it. A new regular tab now leaves non-text preview tabs open, the navigation history records a diff as a place (reopened at its last caret through the editor kind's navigationInput), and Back from a state where nothing shows the current place (its last tab was closed) reopens that place first. Recent Locations still lists text places only.

Co-authored-by: PLZY <[email protected]>
2026-11-17 01:55:55 +08:00
Ernstjan FreriksтаEjaYF 9bf1f320eb feat(database): export with pg_dump and restore with pg_restore / psql (#3718)
PostgreSQL data sources, databases, schemas and tables get Import/Export > Export with 'pg_dump'... and Restore with 'pg_restore'/'psql'....

ide-db finds the installed client tools, turns the dialog's options into the command line, and runs it connected like the data source (SSH tunnel, SSL settings, read-only flag), with the password in PGPASSWORD and never in the arguments. Output streams to the UI; a RequestId cancels the run, which continues after the dialog closes and ends with a notification. The dialogs preselect the client matching the server's major version and warn when it does not fit; Restore reads the dump header to pick psql or pg_restore. Not offered in remote windows.

Co-authored-by: EjaYF <[email protected]>
2026-11-17 01:50:14 +08:00
ntbang0901 921378d531 feat(debugger): trace a Java stream chain while the program runs it (#3727)
Adds Debug > Trace Stream Chain: paused on a line with a java.util.stream chain, the program runs that chain once, for real, while every element is recorded at every step, and a Stream Trace tab shows it Flat (all steps side by side, an element followed through the chain) or Split. Nothing is evaluated twice; the editor stops right after the statement.

- java/jvm-inspect 1.1.0 gets openidea.jvm.stream.*: wraps each step with peek(recorder) (a class defined in the debuggee), runs the terminal operation by invokeMethod, keeps breakpoints off while the chain runs and restores them, then parks the thread. The jar is reproducible from build.py (JDT LS 1.63.0, JDK 25).
- New ide-streams crate finds the chains on the paused line (tree-sitter) and builds the plan; ide-dap drives continue, wait, step out, collect. IPC: debug_stream_chains, debug_stream_trace, debug_stream_trace_abort.
- No automatic timeout: a long chain shows progress with Stop Recording and Abort Operation. At most 50,000 records are kept; banners say when values were dropped, a parallel chain ran sequentially, or breakpoints were off.

Co-authored-by: ntbang0901 <[email protected]>
2026-11-17 01:44:40 +08:00
rohitkumardandaтаrohitdanda 1531220eea feat(agents): generate the commit message with the coding agent (#3766)
Adds Generate Commit Message with Agent above the commit message (Commit tool window and Commit dialog). It sends the included changes (trimmed to a budget) and the last 5 commit subjects to the agent of the project's latest task, on that task's model and in a mode that asks before editing or running anything, as a short quiet task deleted afterwards. The reply replaces the message only if the draft and the included files are unchanged; otherwise a notification says so. Without an installed agent, a notification points to Settings > Agents.

Co-authored-by: rohitdanda <[email protected]>
2026-11-17 01:33:07 +08:00
Muuтаmuutot 96e80f2028 perf(index): answer Python inheritance from the project index (#3759)
The inheritance gutter graph parsed every Python file of the project on each request. The index already parses each file once for symbols, so class base names are now extracted in that pass and stored with the symbol (interned in SymTable); ProjectIndex::inheritance() answers every class from the flat tables and nav_inheritance reads it, so no whole-project parse is left on the request path. Open (possibly unsaved) buffers are still parsed live and replace the index's view of their file. SCHEMA 3 -> 4 rebuilds existing caches once.

Co-authored-by: muutot <[email protected]>
2026-11-17 01:27:54 +08:00
Vadim LazukтаInf1mum e4ac29486c feat(terminal): notify when a long-running command finishes (#3758)
A command run in the integrated terminal gave no sign of finishing once its tab could not be seen. The shell integration now writes the exit status with the OSC 133 end mark (zsh, bash, fish); a session reports a started command's duration, status and whether Ctrl-C stopped it.

When the tab cannot be seen, a finished command raises a balloon in a new terminal group (and so an OS notification in the background): long-running ones by default (10 s threshold), all, or none, set in Settings › Notifications › Terminal. A non-zero exit always reports its code. The balloon's Show action focuses the tab; tabs with an unseen finished command show a dot until focused.

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 01:19:42 +08:00
Vadim LazukтаInf1mum 540094d1ae fix(sdk): detect conda prefix envs even when the env list query misses (#3755)
Environments created with conda create -p outside envs/ reach discovery only through 'conda env list', which starts conda's own Python and reports every prefix's frozen state; conda 26.x regularly needed more than the 4 s --version budget, so the query timed out and every prefix env stayed hidden.

- 'conda env list' gets its own 12 s budget.
- Discovery also reads conda's prefix registry ~/.conda/environments.txt, which names every prefix env even when the query fails or conda is not on PATH.

Co-authored-by: Inf1mum <[email protected]>
2026-11-17 01:14:42 +08:00
l0ng-ai a9ec26aa08 feat(vcs): Deployment submenu in the changes tree's context menu (#3803)
The changes tree's context menu takes other features' groups through a new "changes" menu slot, with the selected files still on disk. Deployment contributes its submenu there (Upload to, Download from, Sync with, Delete from Server, ...), shown when a deployment server is configured.
2026-11-17 01:10:53 +08:00
540 змінених файлів з 27477 додано та 1333 видалено

No files matched your search

Створено
+15
Переглянути файл
@@ -4435,6 +4435,7 @@ dependencies = [
"ide-index",
"ide-jsonrpc",
"ide-jvm-attach",
"ide-jvm-inspect",
"ide-language",
"ide-lsp",
"ide-mcp",
@@ -4447,6 +4448,7 @@ dependencies = [
"ide-search",
"ide-spell",
"ide-ssh",
"ide-streams",
"ide-syntax",
"ide-terminal",
"ide-text",
@@ -4876,6 +4878,19 @@ dependencies = [
"uuid",
]
[[package]]
name = "ide-streams"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-language",
"ide-syntax",
"serde",
"serde_json",
"specta",
"tree-sitter",
]
[[package]]
name = "ide-syntax"
version = "0.1.46"
+1
Переглянути файл
@@ -52,6 +52,7 @@ 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"] }
+101 -23
Переглянути файл
@@ -14,20 +14,21 @@ 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) -> Result<Discovered, String> {
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
match run_once(shared, spec, prefer_stored).await {
match run_once(shared, spec, prefer_stored, model).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).await;
let retry = run_once(shared, spec, true, model).await;
if retry.is_ok() {
crate::provider::mark_prefer_stored_copilot_auth();
}
@@ -37,7 +38,12 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Dis
}
}
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
async fn run_once(
shared: &Arc<Shared>,
spec: &ProviderSpec,
strip_ambient: bool,
selected_model: Option<&str>,
) -> Result<Discovered, String> {
let root = shared.paths.project_root.clone();
let launch = spec.clone();
let launch = tokio::task::spawn_blocking({
@@ -47,28 +53,63 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
.await
.map_err(|e| e.to_string())?;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
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 {} (`{}`): {e}", launch.name, launch.command))?;
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
let _stop = crate::catalogs::KillPeer(peer.clone());
let conn = Conn::new(peer.clone(), client);
let work = async {
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
conn.initialize(&client_info()).await.map_err(discovery_error)?;
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(|e| e.to_string())?;
.map_err(discovery_error)?;
let mut options = config::options_of(&new);
config::add_client_options(&launch.id, &mut options);
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 model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
let mut levels = BTreeMap::new();
if new.get("configOptions").is_some_and(Value::is_array)
&& 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) {
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
.map_err(|_| "The agent did not report settings for the selected model".to_owned())?
};
levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings));
}
let commands = updates
.commands
.lock()
@@ -88,16 +129,38 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
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"
&& 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));
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();
}
}
_ => {}
}
}
@@ -106,8 +169,24 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
}
}
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
let levels: Vec<_> = options
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
.iter()
.filter(|o| config::is_per_model_option(o))
.cloned()
@@ -121,6 +200,5 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<Agen
}
o
})
.collect();
(!levels.is_empty()).then_some(levels)
.collect()
}
+138 -21
Переглянути файл
@@ -45,9 +45,18 @@ 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 {
@@ -204,6 +213,24 @@ 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();
@@ -214,16 +241,27 @@ 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: entry
.retry_at_ms
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
error: entry.error.clone(),
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()),
}
}
@@ -233,6 +271,7 @@ 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);
@@ -264,6 +303,7 @@ impl AgentCatalogs {
let mut catalog = saved.catalog;
if !matching {
catalog.refreshed_at_ms = None;
catalog.thought_levels.clear();
}
catalog
});
@@ -279,31 +319,73 @@ 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 cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
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() && !cooling && (force || !fresh) {
if entry.flight.is_none() && eligible {
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;
start = Some((entry.generation, done));
// Every flight has its own generation, including superseded model selections.
entry.generation = generation;
start = Some((entry.generation, target, done));
}
let snapshot = self.snapshot(shared, &spec.id, entry);
let flight = entry.flight.clone();
drop(state);
if let Some((generation, done)) = start {
if superseded && start.is_none() {
self.broadcast(shared, &snapshot);
}
if let Some((generation, model, 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).await;
coordinator.complete(&shared, flight_key, generation, result);
let result = discover(&shared, spec, model.as_deref()).await;
coordinator.complete(&shared, flight_key, generation, model, result);
let _ = done.send(true);
});
// A subscriber can re-enter and change configuration during the start event.
@@ -319,7 +401,14 @@ impl AgentCatalogs {
(snapshot, flight)
}
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
fn complete(
&self,
shared: &Shared,
key: Key,
generation: u64,
model: Option<String>,
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)
@@ -330,6 +419,7 @@ 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;
@@ -340,12 +430,16 @@ impl AgentCatalogs {
return;
}
let now = self.now();
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
if model.is_none() {
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 {
@@ -354,7 +448,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 entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
for (model, levels) in previous.thought_levels {
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
catalog.thought_levels.insert(model, levels);
}
@@ -373,11 +467,30 @@ 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) => {
entry.error = Some(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);
}
false
}
};
@@ -448,18 +561,22 @@ impl AgentCatalogs {
impl crate::AgentManager {
/// Return cached choices immediately and schedule discovery when eligible.
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> 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).0)
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
}
}
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
async fn discover(
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
model: Option<&str>,
) -> Result<Discovered, String> {
match spec.driver {
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
provider::Driver::Acp => acp::discover::run(shared, &spec, model).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?;
@@ -484,7 +601,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
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).await;
return acp::discover::run(shared, &acp_spec, model).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
@@ -513,7 +630,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec).await
acp::discover::run(shared, &acp_spec, model).await
}
Err(err) => Err(err.message),
}
+345 -56
Переглянути файл
@@ -11,8 +11,10 @@ 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 {
@@ -31,6 +33,10 @@ 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));
@@ -42,26 +48,53 @@ 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();
while let Some(line) = lines.next_line().await.unwrap() {
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;
}
};
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": {
"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,
"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;
}
}
}
};
match result {
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
@@ -190,7 +223,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).unwrap();
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
assert!(cached.refreshing);
assert_eq!(model_values(&cached), ["old", "retained"]);
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
@@ -204,13 +237,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).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false, None).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).unwrap();
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).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();
@@ -229,7 +262,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).unwrap();
manager.refresh_models(PROVIDER, false, None).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
@@ -241,16 +274,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).unwrap();
let catalog = manager.refresh_models(PROVIDER, false, None).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).unwrap();
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).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).unwrap();
manager.refresh_models(PROVIDER, true, None).unwrap();
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
let fresh = completed(&mut events).await;
assert_eq!(efforts(&fresh, "first"), ["medium"]);
@@ -273,7 +306,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).unwrap();
let cached = manager.refresh_models(PROVIDER, false, None).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();
@@ -292,11 +325,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).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let pending = harness.next().await;
for _ in 0..10 {
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
}
let commands = tokio::spawn({
let first = first.clone();
@@ -309,21 +342,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).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
}
advance(&catalogs, 29);
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
advance(&catalogs, 1);
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true, None).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).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
advance(&catalogs, 1);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false, None).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);
@@ -337,25 +370,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).unwrap();
manager.refresh_models(PROVIDER, true, None).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).unwrap();
manager.refresh_models(PROVIDER, false, None).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("Authentication expired"));
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
advance(&catalogs, 29);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
advance(&catalogs, 1);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
let recovered = completed(&mut events).await;
assert_eq!(model_values(&recovered), ["recovered"]);
@@ -370,21 +403,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).unwrap();
manager.refresh_models(PROVIDER, false, None).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).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false, None).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).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
completed(&mut events).await;
}
@@ -398,16 +431,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).unwrap();
first.refresh_models(PROVIDER, false, None).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "two");
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false, None).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).unwrap();
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
assert_eq!(shown.config, fresh.config);
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
assert!(!shown.refreshing);
@@ -415,7 +448,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).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
completed(&mut events).await;
}
@@ -425,7 +458,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).is_err());
assert!(manager.refresh_models("missing-provider", true, None).is_err());
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
}
@@ -437,18 +470,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).unwrap();
manager.refresh_models(PROVIDER, false, None).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).unwrap();
manager.refresh_models(PROVIDER, false, None).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).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false, None).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);
@@ -468,18 +501,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).unwrap();
first.refresh_models(PROVIDER, false, None).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).unwrap();
second.refresh_models(PROVIDER, false, None).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).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
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.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).unwrap();
let cached = restored.refresh_models(PROVIDER, false, None).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);
@@ -488,7 +521,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).unwrap();
let stale = changed.refresh_models(PROVIDER, false, None).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");
@@ -505,7 +538,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).unwrap();
manager.refresh_models(PROVIDER, false, None).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "after");
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
@@ -513,7 +546,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).unwrap();
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
}
@@ -526,13 +559,269 @@ 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).unwrap();
manager.refresh_models(PROVIDER, true, None).unwrap();
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true).unwrap();
manager.refresh_models(PROVIDER, true, None).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 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"]);
}
+104 -24
Переглянути файл
@@ -363,6 +363,7 @@ 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`.
@@ -621,7 +622,7 @@ impl AgentManager {
.into_iter()
.find(|spec| spec.id == provider)
{
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
@@ -954,19 +955,36 @@ 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 = {
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)));
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)));
}
o.clone()
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)
};
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();
@@ -976,36 +994,77 @@ 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) => {
{
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());
}
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
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 !model_options {
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
return Ok(());
}
if !model_options && target.category.as_deref() == Some("model") {
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) {
@@ -1583,6 +1642,7 @@ 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),
@@ -3093,12 +3153,32 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
})
}
fn apply_config_choice(task: &Task, option: &str, value: &str) {
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");
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);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
if let Some(previous) = previous {
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = Some(value.to_owned());
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);
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
}
+159 -5
Переглянути файл
@@ -51,6 +51,7 @@ 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,
@@ -231,6 +232,12 @@ 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())}));
}
@@ -590,6 +597,7 @@ 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] {
@@ -1931,8 +1939,7 @@ 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() {
// 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.
// Idle selections use cached model controls or discover them before the next prompt.
for (option, value) in [("mode", "code"), ("model", "big")] {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
@@ -1945,7 +1952,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude".into(),
provider: "claude-acp".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
@@ -1957,18 +1964,165 @@ 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").unwrap();
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").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"].thought_levels, p.thought_levels, "{option}");
assert_eq!(saved["claude-acp"].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)] {
+83 -1
Переглянути файл
@@ -1,13 +1,16 @@
//! 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::{SyncOptions, error_summary};
use crate::sync::{self, 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)]
@@ -158,6 +161,54 @@ 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::*;
@@ -234,6 +285,37 @@ 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() {
+70 -5
Переглянути файл
@@ -19,7 +19,7 @@ pub mod web;
mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
@@ -127,10 +127,22 @@ pub fn gradle_external_roots(
gradle::external_roots(root, dirs.iter().map(String::as_str))
}
/// 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);
/// 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));
}
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))
}
@@ -251,6 +263,59 @@ 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();
+86 -2
Переглянути файл
@@ -1235,6 +1235,86 @@ 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()
@@ -2479,8 +2559,12 @@ 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");
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
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()]);
let removed = load_with_linked(&a, None, &[], &[]);
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
+3 -3
Переглянути файл
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
Ok(true)
}
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
}
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
pub(crate) 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.
fn hash_gradle_files(files: &[PathBuf]) -> String {
pub(crate) 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");
+3
Переглянути файл
@@ -343,6 +343,8 @@ 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.
@@ -373,6 +375,7 @@ 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,
+96
Переглянути файл
@@ -1,3 +1,6 @@
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> {
@@ -16,6 +19,61 @@ 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]
@@ -26,4 +84,42 @@ 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());
}
}
+94 -1
Переглянути файл
@@ -653,6 +653,10 @@ 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>,
}
@@ -661,9 +665,24 @@ 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, groups: BTreeMap::new() }
Self {
balloons: true,
sound: false,
system_notifications: true,
terminal_completion: default_terminal_completion(),
terminal_threshold_seconds: default_terminal_threshold_seconds(),
groups: BTreeMap::new(),
}
}
}
@@ -741,6 +760,9 @@ 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,
@@ -840,6 +862,7 @@ 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,
@@ -892,7 +915,13 @@ 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.
@@ -936,7 +965,10 @@ 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,
@@ -959,6 +991,23 @@ 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 {
@@ -1751,6 +1800,41 @@ 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();
@@ -1849,6 +1933,15 @@ 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();
+7
Переглянути файл
@@ -43,6 +43,9 @@ 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,
@@ -54,6 +57,8 @@ 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.
@@ -78,6 +83,7 @@ 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(),
@@ -85,6 +91,7 @@ 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,
+5
Переглянути файл
@@ -216,6 +216,11 @@ 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, watch_link};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, 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};
+43
Переглянути файл
@@ -19,6 +19,7 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
mod stream_trace;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
@@ -39,6 +40,7 @@ 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")]
@@ -146,6 +148,9 @@ 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`].
@@ -602,6 +607,7 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
jvm_heap: false,
js_page: false,
live_evaluate: false,
stream_trace: false,
}
}
@@ -613,6 +619,7 @@ 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
}
@@ -1873,6 +1880,42 @@ 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> {
+14
Переглянути файл
@@ -114,6 +114,8 @@ 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>>,
/// 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>,
@@ -195,6 +197,13 @@ 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);
@@ -270,6 +279,8 @@ 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),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
@@ -741,6 +752,9 @@ 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() {
+377
Переглянути файл
@@ -0,0 +1,377 @@
//! 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,
},
}
/// 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);
}
let mut trace =
Trace { mgr, s, tracer: &*tracer, target: &target, thread_id, progress, id: None, last: Counts::default() };
match trace.drive(plan, cancel).await {
Ok(run) => 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,
/// 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);
let id = self
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET))
.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.
async fn release(&self) {
let Some(id) = self.id else { return };
if self.s.ended.is_cancelled() {
return;
}
if let Ok(Err(e)) = self.until_ended(self.tracer.release(self.target, id)).await {
tracing::debug!(session = self.s.id.0, trace = 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 }
}
+42 -1
Переглянути файл
@@ -1,6 +1,7 @@
//! Protocol flow against an in-memory fake adapter.
mod jvm_inspect;
mod stream_trace;
use super::*;
use crate::adapter::{AdapterIo, LaunchFuture};
@@ -132,6 +133,16 @@ 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).
@@ -185,6 +196,10 @@ 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,
@@ -248,6 +263,7 @@ 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;
@@ -494,7 +510,21 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
{"label": ""},
]})
),
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
"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.stop_after_continue => {
ok!(msg, json!({"allThreadsContinued": true}));
send!(
@@ -507,6 +537,16 @@ 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!(
@@ -1871,6 +1911,7 @@ 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 {
+522
Переглянути файл
@@ -0,0 +1,522 @@
//! 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,
) -> 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 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 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,6 +14,7 @@ mod snowflake;
pub mod source;
pub mod split;
pub mod sql;
pub mod tools;
mod watch;
pub use watch::SourcesWatch;
@@ -787,6 +788,56 @@ 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, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, 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, &source, None);
Ok(tools::command_line(executable, &prepared.args))
}
/// 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)
}
+339
Переглянути файл
@@ -0,0 +1,339 @@
//! 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 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>,
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,
}
/// 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,
},
}
impl DbToolJob {
pub fn tool(&self) -> DbTool {
match self {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
}
}
/// 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),
}
}
}
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.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> {
let mut args: Vec<String> = (!file.is_empty()).then(|| format!("--file={file}")).into_iter().collect();
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
args
}
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> 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('\'', "'\\''"))
}
};
std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ")
}
#[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![],
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 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 }),
["--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()],
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
}
#[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);
}
}
+536
Переглянути файл
@@ -0,0 +1,536 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): 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,
}
impl DbTool {
pub fn program(self) -> &'static str {
self.programs()[0]
}
/// Executable names.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
}
}
pub fn driver(self) -> DbDriver {
DbDriver::Postgres
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// 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())
})
})
}
}
/// 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 that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
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"));
for keg in ["libpq", "postgresql"] {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
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 root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
}
}
} else {
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());
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()))),
}
}
/// 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`: not for the PostgreSQL tools.
MysqlSql,
Unknown,
}
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
use std::io::Read;
if path.is_dir() {
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
}
let mut head = Vec::with_capacity(4096);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(4096)
.read_to_end(&mut head)?;
Ok(kind_of(&head))
}
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` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, 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(5432)));
if !source.user.trim().is_empty() {
args.push(format!("--username={}", source.user.trim()));
}
if !source.database.is_empty() {
args.push(format!("--dbname={}", 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)
}
/// How a tool is started: connection arguments, then the job's, and the environment.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
}
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
args.extend(job.args());
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
}
Prepared { args, env }
}
/// Runs `program` until it exits, passing its output in batches. 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)],
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(Stdio::null())
.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, &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 default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::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, &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 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 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()],
&[],
&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()], &[], &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
#[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,
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\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 },
},
];
for job in jobs {
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &pg(), Some(SECRET));
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
}
std::fs::remove_dir_all(&dir).unwrap();
}
}
+75
Переглянути файл
@@ -228,3 +228,78 @@ 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![],
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(())
}
+21 -2
Переглянути файл
@@ -26,6 +26,8 @@ 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).
@@ -55,6 +57,9 @@ 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).
@@ -72,7 +77,9 @@ pub enum Risk {
impl Capability {
pub fn risk(&self) -> Risk {
match self {
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
Risk::Low
}
Self::EditorWrite
| Self::DatabaseSources
| Self::VcsWrite
@@ -90,7 +97,8 @@ impl Capability {
| Self::Process(_)
| Self::Lsp(_)
| Self::FsRead(_)
| Self::FsWrite(_) => Risk::High,
| Self::FsWrite(_)
| Self::JavaAgent => Risk::High,
}
}
@@ -111,6 +119,7 @@ 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(),
@@ -135,6 +144,7 @@ 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(),
}
}
@@ -246,6 +256,7 @@ 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"),
@@ -259,6 +270,7 @@ 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"),
}
}
}
@@ -330,11 +342,13 @@ 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,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
}
@@ -383,6 +397,7 @@ mod tests {
"editor.write",
"project.write",
"vcs.write",
"build.read",
"storage",
"secrets",
"events",
@@ -392,6 +407,7 @@ mod tests {
"process:cargo",
"lsp:phoxite",
"lsp:rust-analyzer",
"java.agent",
] {
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
}
@@ -425,8 +441,11 @@ mod tests {
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
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
+19 -2
Переглянути файл
@@ -10,6 +10,8 @@
//! - `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};
@@ -267,7 +269,7 @@ impl Ledger {
if cap == &Capability::NetAsk {
grant.net_hosts.clear();
}
if let Capability::Process(_) = cap {
if let Capability::Process(_) | Capability::JavaAgent = cap {
grant.binaries.remove(&s);
for binaries in grant.project_binaries.values_mut() {
binaries.remove(&s);
@@ -290,7 +292,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.
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
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);
@@ -675,6 +677,21 @@ 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();
+25 -1
Переглянути файл
@@ -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.9.0";
pub const ENGINE_VERSION: &str = "1.10.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,6 +360,14 @@ 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::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() {
@@ -730,6 +738,22 @@ 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 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();
+2
Переглянути файл
@@ -30,6 +30,8 @@ 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
+9 -3
Переглянути файл
@@ -30,9 +30,15 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
}
/// 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> {
pub fn refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force)
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
@@ -832,7 +838,7 @@ 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")?)
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
});
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")?) });
+48 -7
Переглянути файл
@@ -311,12 +311,11 @@ pub async fn build_sync(
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
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());
}
// 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());
// 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
@@ -468,7 +467,15 @@ pub async fn gradle_dependencies(
gradle_command: Some(gradle.command.clone()),
..Default::default()
};
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
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)
})
.await
.map_err(join_err);
@@ -476,6 +483,40 @@ 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.
pub async fn maven_dependency_declaration(
host: &Host,
+32
Переглянути файл
@@ -532,3 +532,35 @@ 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
}
+86 -1
Переглянути файл
@@ -31,6 +31,8 @@ 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"
@@ -119,6 +121,15 @@ 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
{
@@ -154,10 +165,54 @@ 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));
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
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
@@ -813,6 +868,36 @@ 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));
+15 -6
Переглянути файл
@@ -5,7 +5,7 @@ use crate::rpc::Dispatcher;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
use ide_language::{FoldRange, SyntaxHighlights};
use ide_text::LineEnding;
use ide_workspace::{DocumentEncoding, DocumentInfo, HistoryEntry};
use ide_workspace::{DocumentEncoding, DocumentInfo, DocumentLanguage, HistoryEntry};
use std::path::PathBuf;
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool,
@@ -32,11 +32,17 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
.await
}
/// The CodeMirror mode `path` gets when opened (`DocumentInfo::ui_mode`),
/// without opening it: previews of closed files.
pub async fn doc_ui_mode(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<String>> {
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
/// for hashbang detection; without it the file's on disk counts.
pub async fn doc_language(
host: &Host,
window: &str,
path: PathBuf,
first_line: Option<String>,
) -> IdeResult<DocumentLanguage> {
let project = host.project(window)?;
blocking(move || Ok(project.documents.ui_mode_of(&path))).await
blocking(move || Ok(project.documents.language_of(&path, first_line.as_deref()))).await
}
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
@@ -209,7 +215,10 @@ pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<Strin
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
d.add("doc_ui_mode", |c| async move { doc_ui_mode(&c.host, &c.window, c.arg("path")?).await });
d.add(
"doc_language",
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
);
d.add("doc_set_encoding", |c| async move {
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
});
+2
Переглянути файл
@@ -33,6 +33,7 @@ pub mod sdk;
pub mod search;
pub mod spell;
mod ssh;
pub mod stream_trace;
pub mod syntax;
pub mod term;
pub mod tools;
@@ -88,6 +89,7 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
java::register(d);
debug::register(d);
heap::register(d);
stream_trace::register(d);
bytes::register(d);
vcs::register(d);
doc::register(d);
+35 -27
Переглянути файл
@@ -208,41 +208,52 @@ pub async fn nav_index_definitions(
}
/// Every Python class in the project (attached dependency roots included) and its base
/// names. The index covers content roots, so this is the whole-project answer the UI uses
/// for inheritance gutter markers when no type-hierarchy provider exists.
/// names, answered from the project index: its symbols already carry the bases, and it
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
let project = host.project(window)?;
let syntax = host.syntax();
blocking(move || {
let python = LanguageId::new("python");
let files = project.index.files_with_extensions(&["py".into(), "pyi".into()], 20_000);
let mut cache = CLASS_BASES.lock();
let mut out = Vec::new();
for path in files {
// The open (possibly unsaved) buffer is keyed by its text, a file on disk by its
// size and modification time, so only changed files are parsed again.
// Disk-backed classes come from the index: it already parsed every file once for
// symbols, so no second parse of the project is needed here.
let mut out: Vec<ClassInheritance> = project
.index
.inheritance()
.into_iter()
// The index holds classes of every language; the graph is Python's.
.filter(|c| matches!(c.path.extension().and_then(std::ffi::OsStr::to_str), Some("py" | "pyi")))
.map(|c| ClassInheritance {
path: IpcPath::from(c.path.clone()),
line: c.range.start.line,
col: c.range.start.col,
name: c.name.clone(),
bases: c.bases.clone(),
})
.collect();
// Open buffers may be unsaved, so their classes are parsed live (and cached per
// text/stamp) and replace the index's view of that file. This keeps #3359's
// "open buffer by its text" behaviour while the disk path is index-backed.
let open_files: Vec<PathBuf> = project
.index
.files_with_extensions(&["py".into(), "pyi".into()], 20_000)
.into_iter()
.filter(|path| project.documents.text_of(path).is_some())
.collect();
for path in open_files {
let open = project.documents.text_of(&path);
let stamp = match &open {
Some(text) => Stamp::Text(text_hash(text)),
None => match std::fs::metadata(&path) {
Ok(m) => Stamp::Disk(m.len(), m.modified().ok()),
Err(_) => continue,
},
Some(text) => Stamp(text_hash(text)),
None => continue,
};
let text = open.unwrap();
let classes = match cache.get(&path) {
Some((cached, classes)) if *cached == stamp => classes,
_ => {
let text = match open {
Some(text) => text,
None => match project.text_of(&path) {
Ok(text) => text,
Err(_) => continue,
},
};
let classes = syntax.class_bases(&python, &text);
&cache.entry(path.clone()).insert_entry((stamp, classes)).into_mut().1
}
_ => &cache.entry(path.clone()).insert_entry((stamp, syntax.class_bases(&python, &text))).into_mut().1,
};
out.retain(|c| c.path.0 != *path);
out.extend(classes.iter().map(|class| ClassInheritance {
path: IpcPath::from(path.clone()),
line: class.line,
@@ -257,10 +268,7 @@ pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassIn
}
#[derive(Clone, PartialEq, Eq)]
enum Stamp {
Text(u64),
Disk(u64, Option<std::time::SystemTime>),
}
struct Stamp(u64);
fn text_hash(text: &str) -> u64 {
use std::hash::{Hash, Hasher};
+25
Переглянути файл
@@ -301,6 +301,8 @@ async fn start_inner(
if config.command.is_empty() {
return Err(IdeError::invalid("run configuration has no command"));
}
let on_target = config.extras.target.as_deref().is_some_and(|t| !t.is_empty());
add_java_agents(&mut config, &on_output, !on_target);
// Settings › Run Targets: over SSH, or in a container.
if config.kind == "tomcat" && config.extras.target.as_deref().is_some_and(|t| !t.is_empty()) {
return Err(IdeError::invalid("Tomcat Local requires the local machine"));
@@ -446,6 +448,29 @@ async fn start_inner(
host.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))
}
/// Plugins' Java agents (`[[contributes.javaAgents]]`, granted `java.agent`) for the JVM of an
/// Application, Spring Boot or JAR Application configuration started on this machine. A JVM on a
/// run target gets none; the console says so, and why an approved agent was left out.
fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local: bool) {
if !ide_run::java_agent::applies(&config.kind) {
return;
}
let agents = ide_run::java_agent::current();
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
if !local {
if !agents.options.is_empty() {
say(
"Plugin Java agents were not added: they load only into JVMs started on this machine, not on a run target.",
);
}
return;
}
for note in &agents.notes {
say(note);
}
ide_run::java_agent::add_to_args(&mut config.args, &agents.options);
}
/// The Ruby test reporter's directory, installed on demand, for runs that take it.
fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {
if !ide_run::ruby_reporter::applies(config) {
+462
Переглянути файл
@@ -0,0 +1,462 @@
//! Java Stream Debugger: the stream chains around a debugger stop, and traces of a chain's real run.
//! `ide_streams` finds the chains and links what the run recorded; `ide_dap` runs the trace.
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
use ide_dap::{StackFrame, TraceRun};
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
pub use ide_jvm_inspect::{AbortState, JvmValue};
use ide_jvm_inspect::{CollectedTerminal, TraceCollected};
use ide_streams::{
BoxKind, RealRunPlan, RealRunRefusal, Record, Rejection, StopContext, StreamChain, TerminalOutcome, TraceRecording,
TraceValue, find_chains, link_trace, real_run_plan, recorded_steps,
};
pub use ide_streams::{Link, TraceBanner};
use ide_syntax::{Snapshot, StructureService};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StreamChainInfo {
/// The `chain_index` [`debug_stream_trace`] takes for the same frame.
pub index: u32,
pub range: Range,
pub text: String,
/// Intermediate operations in call order, modifiers included. Empty, like `terminal`, for a
/// chain the search rejected.
pub steps: Vec<String>,
pub terminal: String,
pub available: bool,
/// Set exactly when `available` is false.
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub reason: Option<ChainUnavailable>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum ChainUnavailable {
NotTopFrame,
NotAtChainStart,
InsideChainLambda,
NotJavaStreamRoot {
root: String,
},
LazyTerminal {
op: String,
},
NoTerminal,
UnknownOperation {
op: String,
},
SyntaxError,
/// The session has no stream tracer: not java-debug, or its jdtls has no inspector bundle.
NoBackend,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum StreamTraceResult {
Ready {
chain: Box<StreamChainInfo>,
/// Column titles by recorded step: `steps[0]` is the root call's name (empty for a stream
/// held in a local), then each operation that records, modifiers left out.
steps: Vec<String>,
/// In recording order.
records: Vec<TraceRecordView>,
/// Parallel to `records`.
links: Vec<Link>,
terminal: TerminalView,
banners: Vec<TraceBanner>,
/// The stop the values belong to, for `debug_jvm_memory_fields`.
generation: u64,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Recording was stopped, or the operation aborted, before the chain ran: nothing went wrong.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceRecordView {
pub step: u16,
pub value: JvmValue,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TerminalView {
Value { value: JvmValue },
Void,
Threw { exception: JvmValue },
}
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
pub async fn debug_stream_chains(
host: &Host,
window: &str,
session: DebugSessionId,
frame: StackFrame,
top: bool,
) -> IdeResult<Vec<StreamChainInfo>> {
host.require_trust(window)?;
let backend = host.debugger.capabilities(session)?.stream_trace;
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
}
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
/// can move another chain to the same index. Cancelling `request` stops recording while the
/// program runs on.
#[allow(clippy::too_many_arguments)]
pub async fn debug_stream_trace(
host: &Host,
window: &str,
session: DebugSessionId,
request: RequestId,
thread_id: i64,
frame: StackFrame,
chain_index: u32,
range: Range,
on_progress: Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let chain = ChainRef { frame, index: chain_index, range };
let result = trace(host, window, session, thread_id, chain, &cancel, &on_progress).await;
host.end_request(request);
result
}
/// The chain the UI chose, as [`debug_stream_chains`] listed it.
struct ChainRef {
frame: StackFrame,
index: u32,
range: Range,
}
async fn trace(
host: &Host,
window: &str,
session: DebugSessionId,
thread_id: i64,
chosen: ChainRef,
cancel: &CancellationToken,
on_progress: &Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
let line = chosen.frame.line;
// `stream_trace` decides whether the session can trace, so the backend is assumed here.
let candidate = candidates(host, window, chosen.frame, true, true)
.await?
.into_iter()
.nth(chosen.index as usize)
.filter(|c| c.info.range == chosen.range);
let Some(candidate) = candidate else {
return Ok(StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() });
};
if let Some(reason) = candidate.info.reason.clone() {
let reason = trace_unavailable(reason, line, candidate.chain.as_ref());
return Ok(StreamTraceResult::Unavailable { reason });
}
let Some(chain) = candidate.chain else {
return Err(IdeError::internal("an available stream chain has no parsed chain"));
};
let plan = real_run_plan(&chain).map_err(|e| IdeError::internal(format!("stream chain plan: {e:?}")))?;
let plan_json = serde_json::to_value(&plan).map_err(|e| IdeError::internal(e.to_string()))?;
// `stream_trace` resumes the program before it looks at `cancel`.
if cancel.is_cancelled() {
return Ok(StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() });
}
let progress = |p| {
let _ = on_progress.send(p);
};
let run = host.debugger.stream_trace(session, thread_id, plan_json, cancel.clone(), progress).await?;
Ok(match run {
TraceRun::Done { collected, generation, resumed_stops } => {
let info = candidate.info;
host.blocking(move || Ok(ready(info, &chain, &plan, collected, generation, resumed_stops))).await?
}
TraceRun::Unavailable { reason } => StreamTraceResult::Unavailable { reason },
TraceRun::Failed { detail } => StreamTraceResult::Failed { detail },
TraceRun::Cancelled { detail } => StreamTraceResult::Cancelled { detail },
})
}
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
pub async fn debug_stream_trace_abort(
host: &Host,
window: &str,
session: DebugSessionId,
) -> IdeResult<Option<AbortState>> {
host.require_trust(window)?;
host.debugger.stream_trace_abort(session).await
}
struct Candidate {
info: StreamChainInfo,
/// `None` for a chain the search rejected.
chain: Option<StreamChain>,
}
/// The file's current text (the open buffer, else the disk) searched off the command thread.
/// Frames outside readable Java sources have no chains: java-debug gives library frames
/// `jdt://contents/…` paths.
async fn candidates(
host: &Host,
window: &str,
frame: StackFrame,
top: bool,
backend: bool,
) -> IdeResult<Vec<Candidate>> {
let Some(path) = frame.path.clone() else { return Ok(Vec::new()) };
let project = host.project(window)?;
host.blocking(move || {
let path = path.into_path_buf();
let cancel = CancellationToken::new();
let search = |snap: &Snapshot| {
if snap.language.as_str() != "java" {
return Ok(Vec::new());
}
chains_at(&project.structure, snap, &frame, top, backend, &cancel)
};
if let Some(doc) = project.documents.by_path(&path) {
let snap = project.documents.text_snapshot(doc)?;
if snap.large {
return Err(IdeError::unavailable("file is too large for syntax analysis"));
}
return search(&Snapshot::doc(doc, snap.version, &snap.language, &snap.text));
}
let language: LanguageId = project.languages.detect(&path, None);
if language.as_str() != "java" {
return Ok(Vec::new());
}
let Ok(text) = project.text_of(&path) else { return Ok(Vec::new()) };
search(&Snapshot::text(&language, &text))
})
.await
}
fn chains_at(
service: &StructureService,
snap: &Snapshot,
frame: &StackFrame,
top: bool,
backend: bool,
cancel: &CancellationToken,
) -> IdeResult<Vec<Candidate>> {
let path = frame.path.as_ref().map(|p| p.0.as_path());
let file_stem = path.and_then(Path::file_stem).and_then(|s| s.to_str()).unwrap_or_default();
let stop = StopContext { line: frame.line, in_lambda: frame.name.contains("lambda$"), file_stem };
let found = find_chains(service, snap, &stop, cancel)?;
let mut candidates: Vec<Candidate> = found
.chains
.into_iter()
.map(|chain| {
let reason = refusal(&chain, frame.line, top, backend);
let info = StreamChainInfo {
index: 0,
range: chain.range,
text: chain.text.clone(),
steps: chain.ops.iter().map(|op| op.name.clone()).collect(),
terminal: chain.terminal.name.clone(),
available: reason.is_none(),
reason,
};
Candidate { info, chain: Some(chain) }
})
.collect();
candidates.extend(found.rejected.into_iter().map(|rejected| {
let reason = if top { rejection(rejected.reason) } else { ChainUnavailable::NotTopFrame };
let info = StreamChainInfo {
index: 0,
range: rejected.range,
text: rejected.text,
steps: Vec::new(),
terminal: String::new(),
available: false,
reason: Some(reason),
};
Candidate { info, chain: None }
}));
candidates.sort_by_key(|c| c.info.range);
for (i, c) in candidates.iter_mut().enumerate() {
c.info.index = i as u32;
}
Ok(candidates)
}
fn refusal(chain: &StreamChain, line: u32, top: bool, backend: bool) -> Option<ChainUnavailable> {
if !top {
return Some(ChainUnavailable::NotTopFrame);
}
// ECJ puts the first instruction of `T x =\n root…` on the root's line, not the
// statement's; the bundle makes the final call from the line table.
if line < chain.first_line || line > root_line(chain) {
return Some(ChainUnavailable::NotAtChainStart);
}
if let Err(refused) = real_run_plan(chain) {
return Some(refusal_reason(refused));
}
(!backend).then_some(ChainUnavailable::NoBackend)
}
fn root_line(chain: &StreamChain) -> u32 {
let before_root = chain.text.get(..chain.root.span.0).unwrap_or_default();
chain.range.start.line + before_root.matches('\n').count() as u32
}
fn refusal_reason(refused: RealRunRefusal) -> ChainUnavailable {
match refused {
RealRunRefusal::NotJavaStreamRoot { root } => ChainUnavailable::NotJavaStreamRoot { root },
RealRunRefusal::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
RealRunRefusal::NoTerminal => ChainUnavailable::NoTerminal,
RealRunRefusal::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
RealRunRefusal::InsideChainLambda => ChainUnavailable::InsideChainLambda,
RealRunRefusal::SyntaxError => ChainUnavailable::SyntaxError,
}
}
fn rejection(rejected: Rejection) -> ChainUnavailable {
match rejected {
Rejection::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
Rejection::NoTerminal => ChainUnavailable::NoTerminal,
Rejection::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
Rejection::InsideChainLambda => ChainUnavailable::InsideChainLambda,
Rejection::SyntaxError => ChainUnavailable::SyntaxError,
}
}
/// The same reasons as the bundle's refusals, for a chain that stopped being traceable between
/// [`debug_stream_chains`] and [`debug_stream_trace`].
fn trace_unavailable(reason: ChainUnavailable, line: u32, chain: Option<&StreamChain>) -> TraceUnavailable {
let unsupported = |detail: String| TraceUnavailable::Unsupported { detail };
match reason {
ChainUnavailable::NotAtChainStart => {
let start = chain.map_or(String::new(), |c| format!(", the chain starts on line {}", c.first_line + 1));
TraceUnavailable::NotAtChainStart { detail: format!("the stop is on line {}{start}", line + 1) }
}
ChainUnavailable::NoBackend => TraceUnavailable::NoBackend,
ChainUnavailable::NotTopFrame => unsupported("only the top frame can be traced".into()),
ChainUnavailable::InsideChainLambda => unsupported("the chain is already running".into()),
ChainUnavailable::NotJavaStreamRoot { root } => {
unsupported(format!("the stream {root} does not start in this statement"))
}
ChainUnavailable::LazyTerminal { op } => unsupported(format!("{op}() does not run the pipeline")),
ChainUnavailable::NoTerminal => unsupported("the chain has no terminal operation".into()),
ChainUnavailable::UnknownOperation { op } => unsupported(format!("unknown stream operation {op}()")),
ChainUnavailable::SyntaxError => unsupported("the statement does not parse".into()),
}
}
fn ready(
chain_info: StreamChainInfo,
chain: &StreamChain,
plan: &RealRunPlan,
collected: TraceCollected,
generation: u64,
resumed_stops: u32,
) -> StreamTraceResult {
let recording = TraceRecording {
records: collected.records.iter().map(|(step, v)| Record { step: *step, value: trace_value(v) }).collect(),
dropped: collected.dropped,
terminal: match &collected.terminal {
CollectedTerminal::Value(v) => TerminalOutcome::Value { value: trace_value(v) },
CollectedTerminal::Void => TerminalOutcome::Void,
CollectedTerminal::Threw(e) => TerminalOutcome::Threw { exception: trace_value(e) },
},
};
let mut linked = link_trace(plan, &recording, collected.skipped_breakpoints);
if resumed_stops > 0 {
linked.banners.push(TraceBanner::BreakpointsResumed { count: resumed_stops });
}
StreamTraceResult::Ready {
chain: Box::new(chain_info),
steps: recorded_steps(chain),
records: collected.records.into_iter().map(|(step, value)| TraceRecordView { step, value }).collect(),
links: linked.links,
terminal: match collected.terminal {
CollectedTerminal::Value(value) => TerminalView::Value { value },
CollectedTerminal::Void => TerminalView::Void,
CollectedTerminal::Threw(exception) => TerminalView::Threw { exception },
},
banners: linked.banners,
generation,
}
}
fn trace_value(value: &JvmValue) -> TraceValue {
match value {
JvmValue::Null => TraceValue::Null,
JvmValue::Boxed { id, type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: *id, class, value: text.clone() },
None => TraceValue::Object { id: *id, class: type_name.clone() },
},
JvmValue::Str { id, text, .. } => {
TraceValue::Str { id: *id, value: text.clone().unwrap_or_default(), truncated: text.is_none() }
}
JvmValue::Object { id, type_name } | JvmValue::Array { id, type_name, .. } => {
TraceValue::Object { id: *id, class: type_name.clone() }
}
// The recorder boxes every element, so only a terminal's result is primitive, and linking
// never reads that.
JvmValue::Primitive { type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: 0, class, value: text.clone() },
None => TraceValue::Null,
},
}
}
/// Wrapper class names (boxed values) and primitive type names (primitive values) alike.
fn box_kind(type_name: &str) -> Option<BoxKind> {
Some(match type_name {
"java.lang.Boolean" | "boolean" => BoxKind::Boolean,
"java.lang.Byte" | "byte" => BoxKind::Byte,
"java.lang.Character" | "char" => BoxKind::Char,
"java.lang.Short" | "short" => BoxKind::Short,
"java.lang.Integer" | "int" => BoxKind::Int,
"java.lang.Long" | "long" => BoxKind::Long,
"java.lang.Float" | "float" => BoxKind::Float,
"java.lang.Double" | "double" => BoxKind::Double,
_ => return None,
})
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_stream_chains", |c| async move {
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
});
d.add("debug_stream_trace", |c| async move {
debug_stream_trace(
&c.host,
&c.window,
c.arg("session")?,
c.arg("request")?,
c.arg("threadId")?,
c.arg("frame")?,
c.arg("chainIndex")?,
c.arg("range")?,
c.sender("onProgress")?,
)
.await
});
d.add("debug_stream_trace_abort", |c| async move {
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
});
}
#[cfg(test)]
mod tests;
+444
Переглянути файл
@@ -0,0 +1,444 @@
use super::*;
use ide_core::{CancellationToken, LanguageId};
use ide_language::{Syntax, SyntaxCache};
use ide_streams::BoxKind;
use serde_json::json;
use std::sync::{Arc, OnceLock};
const SOURCE: &str = r#"import java.util.*;
import java.util.stream.*;
class Chains {
Stream<Integer> items;
void run(List<Integer> nums) {
List<Integer> evens = nums.stream() // C_EVENS
.filter(x -> x % 2 == 0) // C_EVENS_FILTER
.collect(Collectors.toList());
List<Integer> out = // C_DECL
nums.stream() // C_ROOT
.map(x -> x + 1) // C_ROOT_MAP
.collect(Collectors.toList());
long n = this.items.filter(x -> x > 0).count(); // C_FIELD
Iterator<Integer> it = nums.stream().map(x -> x).iterator(); // C_LAZY
List<String> a = nums.stream().filter(x -> x % 2 == 0).map(x -> x * 10 + 1).sorted().map(String::valueOf).collect(Collectors.toList()); // C_SPIKE
}
}
"#;
fn service() -> &'static StructureService {
static S: OnceLock<StructureService> = OnceLock::new();
S.get_or_init(|| StructureService::new(Arc::new(SyntaxCache::new(Arc::new(Syntax::new())))))
}
fn line_of(marker: &str) -> u32 {
let tag = format!("// {marker}");
let found = SOURCE.lines().position(|l| l.trim_end().ends_with(&tag));
found.unwrap_or_else(|| panic!("no line marked {marker}")) as u32
}
fn frame(line: u32) -> StackFrame {
StackFrame {
id: 1,
name: "Chains.run(List)".into(),
path: Some("/project/src/Chains.java".into()),
line,
column: 8,
presentation_hint: None,
}
}
fn chains_on(line: u32, top: bool, backend: bool) -> Vec<StreamChainInfo> {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line), top, backend, &CancellationToken::new()).expect("search");
found.into_iter().map(|c| c.info).collect()
}
fn availability(info: &StreamChainInfo) -> serde_json::Value {
let mut v = serde_json::to_value(info).unwrap();
let map = v.as_object_mut().unwrap();
json!({ "available": map.remove("available"), "reason": map.remove("reason") })
}
#[test]
fn chains_refuse_non_top_frame() {
let infos = chains_on(line_of("C_EVENS"), false, true);
assert!(!infos.is_empty());
for info in &infos {
assert_eq!(availability(info), json!({"available": false, "reason": {"kind": "notTopFrame"}}), "{info:?}");
}
}
#[test]
fn chains_need_first_line() {
let infos = chains_on(line_of("C_EVENS_FILTER"), true, true);
assert_eq!(infos.len(), 1, "{infos:?}");
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
let mid = chains_on(line_of("C_ROOT_MAP"), true, true);
assert_eq!(availability(&mid[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
}
/// ECJ puts a declaration's first instruction on the line of its initializer's root call.
#[test]
fn chains_accept_the_root_line_of_a_declaration() {
let at_root = chains_on(line_of("C_ROOT"), true, true);
assert_eq!(at_root.len(), 1, "{at_root:?}");
assert_eq!(availability(&at_root[0]), json!({"available": true, "reason": null}));
let at_head = chains_on(line_of("C_DECL"), true, true);
assert_eq!(availability(&at_head[0]), json!({"available": true, "reason": null}));
}
#[test]
fn chains_list_rejections() {
let field = chains_on(line_of("C_FIELD"), true, true);
assert_eq!(field.len(), 1, "{field:?}");
assert_eq!(
availability(&field[0]),
json!({"available": false, "reason": {"kind": "notJavaStreamRoot", "root": "this.items"}})
);
let lazy = chains_on(line_of("C_LAZY"), true, true);
assert_eq!(lazy.len(), 1, "{lazy:?}");
assert_eq!(
availability(&lazy[0]),
json!({"available": false, "reason": {"kind": "lazyTerminal", "op": "iterator"}})
);
}
#[test]
fn chains_without_a_tracer_have_no_backend() {
let infos = chains_on(line_of("C_EVENS"), true, false);
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "noBackend"}}));
}
#[test]
fn chain_info_json_shape() {
let infos = chains_on(line_of("C_EVENS"), true, true);
let v = serde_json::to_value(&infos[0]).unwrap();
assert_eq!(v["index"], 0);
assert_eq!(v["steps"], json!(["filter"]));
assert_eq!(v["terminal"], "collect");
assert_eq!(v["range"]["start"]["line"], line_of("C_EVENS"));
assert_eq!(v["available"], true);
assert!(v.get("reason").is_none(), "{v}");
}
#[test]
fn jvm_value_to_trace_value() {
let boxed = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
assert_eq!(trace_value(&boxed), TraceValue::Boxed { id: 4, class: BoxKind::Int, value: "8".into() });
let long_text = JvmValue::Str { id: 5, text: None, length: 50_000 };
assert_eq!(trace_value(&long_text), TraceValue::Str { id: 5, value: String::new(), truncated: true });
let short_text = JvmValue::Str { id: 6, text: Some("81".into()), length: 2 };
assert_eq!(trace_value(&short_text), TraceValue::Str { id: 6, value: "81".into(), truncated: false });
let object = JvmValue::Object { id: 7, type_name: "com.x.Order".into() };
assert_eq!(trace_value(&object), TraceValue::Object { id: 7, class: "com.x.Order".into() });
let array = JvmValue::Array { id: 8, type_name: "int[]".into(), length: 3 };
assert_eq!(trace_value(&array), TraceValue::Object { id: 8, class: "int[]".into() });
assert_eq!(trace_value(&JvmValue::Null), TraceValue::Null);
let odd_box = JvmValue::Boxed { id: 9, type_name: "java.math.BigInteger".into(), text: "1".into() };
assert_eq!(trace_value(&odd_box), TraceValue::Object { id: 9, class: "java.math.BigInteger".into() });
let count = JvmValue::Primitive { type_name: "long".into(), text: "4".into() };
assert_eq!(trace_value(&count), TraceValue::Boxed { id: 0, class: BoxKind::Long, value: "4".into() });
let odd_primitive = JvmValue::Primitive { type_name: "void".into(), text: String::new() };
assert_eq!(trace_value(&odd_primitive), TraceValue::Null);
}
/// The log measured on `source -> filter -> map -> sorted -> map` (see ide-streams' spike test),
/// as the bundle reports it: every `peek` re-boxes, so no two boxes share an id.
fn spike_collected() -> TraceCollected {
let steps_values: [(u16, &str); 24] = [
(0, "5"),
(0, "3"),
(0, "8"),
(1, "8"),
(2, "81"),
(0, "1"),
(0, "4"),
(1, "4"),
(2, "41"),
(0, "2"),
(1, "2"),
(2, "21"),
(0, "9"),
(0, "6"),
(1, "6"),
(2, "61"),
(3, "21"),
(4, "21"),
(3, "41"),
(4, "41"),
(3, "61"),
(4, "61"),
(3, "81"),
(4, "81"),
];
let records = steps_values
.iter()
.enumerate()
.map(|(i, &(step, text))| {
let id = 100 + i as u64;
let value = if step == 4 {
JvmValue::Str { id, text: Some(text.into()), length: text.len() as u32 }
} else {
JvmValue::Boxed { id, type_name: "java.lang.Integer".into(), text: text.into() }
};
(step, value)
})
.collect();
TraceCollected {
records,
dropped: 3,
terminal: CollectedTerminal::Value(JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() }),
skipped_breakpoints: 2,
sequentialized: false,
}
}
#[test]
fn ready_links_the_collected_records() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let collected = spike_collected();
let expected_records: Vec<TraceRecordView> =
collected.records.iter().map(|(step, value)| TraceRecordView { step: *step, value: value.clone() }).collect();
let StreamTraceResult::Ready { chain: shown, steps, records, links, terminal, banners, generation } =
ready(info.clone(), &chain, &plan, collected, 9, 0)
else {
panic!("not ready");
};
assert_eq!(*shown, info);
assert_eq!(steps, ["stream", "filter", "map", "sorted", "map"]);
assert_eq!(records, expected_records);
assert_eq!(links.len(), records.len());
assert_eq!(links[0], Link { parent: None, ambiguous: false });
// `1=8` comes from the `0=8` just before it, and `2=81` from that.
assert_eq!(links[3].parent, Some(2));
assert_eq!(links[4].parent, Some(3));
// `sorted` emits `3=21` after the whole upstream ran: it is the `2=21` of record 11, linked by
// value although the box was re-made.
assert_eq!(links[16], Link { parent: Some(11), ambiguous: false });
assert_eq!(links[17].parent, Some(16));
assert_eq!(links[22].parent, Some(4));
assert_eq!(
terminal,
TerminalView::Value { value: JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() } }
);
assert_eq!(banners, [TraceBanner::Truncated { dropped: 3 }, TraceBanner::BreakpointsSkipped { count: 2 }]);
assert_eq!(generation, 9);
}
#[test]
fn ready_says_how_many_stops_were_resumed() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, spike_collected(), 9, 3) else {
panic!("not ready");
};
assert_eq!(
banners,
[
TraceBanner::Truncated { dropped: 3 },
TraceBanner::BreakpointsSkipped { count: 2 },
TraceBanner::BreakpointsResumed { count: 3 }
]
);
}
const WINDOW: &str = "main";
/// A real `Host` with a trusted project holding `src/Chains.java` (= [`SOURCE`]).
struct Fixture {
host: Host,
source: std::path::PathBuf,
_temp: tempfile::TempDir,
}
impl Fixture {
async fn new() -> Self {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(root.join("src")).unwrap();
let source = root.join("src/Chains.java");
std::fs::write(&source, SOURCE).unwrap();
let host = Host::new(crate::HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.open_project(WINDOW, &root).unwrap();
host.set_project_trust(&root, true, false).await.unwrap();
Self { host, source, _temp: temp }
}
fn frame(&self, line: u32) -> StackFrame {
StackFrame { path: Some(self.source.as_path().into()), ..frame(line) }
}
async fn chains(&self, frame: StackFrame) -> Vec<StreamChainInfo> {
candidates(&self.host, WINDOW, frame, true, true).await.unwrap().into_iter().map(|c| c.info).collect()
}
async fn trace(&self, request: u32, frame: StackFrame, index: u32, range: Range) -> StreamTraceResult {
let request = RequestId(request);
debug_stream_trace(
&self.host,
WINDOW,
DebugSessionId(404),
request,
1,
frame,
index,
range,
Channel::new(|_| {}),
)
.await
.unwrap()
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn chains_skip_frames_without_a_readable_java_source() {
let f = Fixture::new().await;
assert_eq!(f.chains(f.frame(line_of("C_EVENS"))).await.len(), 1, "the file on disk is read");
let library = StackFrame {
path: Some("jdt://contents/rt.jar/java.util.stream/ReferencePipeline.class?=java/rt.jar".into()),
..frame(120)
};
assert_eq!(f.chains(library).await, []);
let missing = StackFrame { path: Some(f.source.with_file_name("Missing.java").as_path().into()), ..frame(3) };
assert_eq!(f.chains(missing).await, []);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_refuses_a_chain_that_changed() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
let changed = StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() };
let mut moved = listed.range;
moved.end.col += 1;
assert_eq!(f.trace(1, at.clone(), listed.index, moved).await, changed);
assert_eq!(f.trace(2, at, listed.index + 1, listed.range).await, changed);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_reports_an_unavailable_chain_like_the_bundle() {
let f = Fixture::new().await;
let mid = f.frame(line_of("C_EVENS_FILTER"));
let listed = f.chains(mid.clone()).await.remove(0);
let detail = format!(
"the stop is on line {}, the chain starts on line {}",
line_of("C_EVENS_FILTER") + 1,
line_of("C_EVENS") + 1
);
assert_eq!(
f.trace(1, mid, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail } }
);
let field = f.frame(line_of("C_FIELD"));
let listed = f.chains(field.clone()).await.remove(0);
let detail = "the stream this.items does not start in this statement".to_string();
assert_eq!(
f.trace(2, field, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::Unsupported { detail } }
);
}
/// The session id names no session: reaching `stream_trace` would fail the call.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_cancelled_before_it_starts_does_not_run() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
f.host.cancel_request(RequestId(7));
assert_eq!(
f.trace(7, at, listed.index, listed.range).await,
StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() }
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Cancelled { detail: "x".into() }).unwrap(),
json!({"status": "cancelled", "detail": "x"})
);
}
#[test]
fn ready_result_json_shape() {
let info = chains_on(line_of("C_EVENS"), true, true).remove(0);
let value = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
let ready = StreamTraceResult::Ready {
chain: Box::new(info),
steps: vec!["stream".into(), "filter".into()],
records: vec![TraceRecordView { step: 0, value: value.clone() }],
links: vec![Link { parent: None, ambiguous: false }],
terminal: TerminalView::Threw { exception: JvmValue::Object { id: 9, type_name: "java.lang.X".into() } },
banners: vec![TraceBanner::Truncated { dropped: 2 }, TraceBanner::BreakpointsSkipped { count: 1 }],
generation: 3,
};
let v = serde_json::to_value(&ready).unwrap();
assert_eq!(v["status"], "ready");
assert_eq!(v["chain"]["available"], true);
assert_eq!(v["steps"], json!(["stream", "filter"]));
assert_eq!(
v["records"],
json!([{"step": 0, "value": {"kind": "boxed", "id": 4, "typeName": "java.lang.Integer", "text": "8"}}])
);
assert_eq!(v["links"], json!([{"parent": null, "ambiguous": false}]));
assert_eq!(
v["terminal"],
json!({"kind": "threw", "exception": {"kind": "object", "id": 9, "typeName": "java.lang.X"}})
);
assert_eq!(v["banners"], json!([{"kind": "truncated", "dropped": 2}, {"kind": "breakpointsSkipped", "count": 1}]));
assert_eq!(v["generation"], 3);
assert_eq!(serde_json::to_value(TerminalView::Value { value }).unwrap()["kind"], "value");
assert_eq!(serde_json::to_value(TerminalView::Void).unwrap(), json!({"kind": "void"}));
}
#[test]
fn other_results_json_shape() {
let unavailable =
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "line 4".into() } };
assert_eq!(
serde_json::to_value(&unavailable).unwrap(),
json!({"status": "unavailable", "reason": {"kind": "notAtChainStart", "detail": "line 4"}})
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Failed { detail: "boom".into() }).unwrap(),
json!({"status": "failed", "detail": "boom"})
);
let progress = TraceProgress { phase: TracePhase::RecordingStopped, records: 5, dropped: 0, elapsed_ms: 40 };
assert_eq!(
serde_json::to_value(&progress).unwrap(),
json!({"phase": "recordingStopped", "records": 5, "dropped": 0, "elapsedMs": 40})
);
let stuck = AbortState::Stuck { holders: vec![(3, "main".into())] };
assert_eq!(serde_json::to_value(&stuck).unwrap(), json!({"kind": "stuck", "holders": [[3, "main"]]}));
assert_eq!(serde_json::to_value(AbortState::Interrupted).unwrap(), json!({"kind": "interrupted"}));
}
#[test]
fn chain_info_steps_keep_modifiers() {
let java = LanguageId::new("java");
let source = "class Chains { void run(java.util.List<Integer> nums) {\n\
long n = nums.parallelStream().filter(x -> x > 0).unordered().map(x -> x).count();\n} }";
let snap = Snapshot::text(&java, source);
let found = chains_at(service(), &snap, &frame(1), true, true, &CancellationToken::new()).unwrap();
assert_eq!(found[0].info.steps, ["filter", "unordered", "map"]);
}
+28 -7
Переглянути файл
@@ -112,6 +112,11 @@ pub trait PluginWorkspace: Send + Sync {
) -> Result<serde_json::Value, HostError> {
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// What the IDE has resolved of the Maven / Gradle builds of the project at `root`;
/// never runs a build tool.
fn build_graph(&self, _root: &Path) -> Result<super::BuildGraph, HostError> {
Ok(super::BuildGraph::default())
}
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
fn symbols(
&self,
@@ -1551,13 +1556,8 @@ impl HostApi for PluginApi {
}
Ok(())
}
fn open_diff(
&self,
client: &str,
diff: ide_plugin::ContentDiff,
file_name: Option<String>,
) -> Result<(), HostError> {
super::execution::validate_diff(&diff)?;
fn open_diff(&self, client: &str, diff: ide_plugin::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
super::execution::validate_file_diff(&diff)?;
if let Some(name) = &file_name {
super::execution::label(name, 256)?;
}
@@ -2229,6 +2229,20 @@ impl HostApi for PluginApi {
Ok(result.to_string())
}
fn build_dependencies(
&self,
root: &Path,
module: Option<&str>,
) -> Result<Vec<ide_plugin::DependencyNode>, HostError> {
self.require_api("`build`", 10)?;
let workspace = self.shared.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
// The graph comes from running the project's build, as `vcs.read` does git.
if !workspace.trusted(root) {
return Err(HostError::Denied("project is not trusted".into()));
}
super::build_graph::dependency_nodes(&workspace.build_graph(root)?, module)
}
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
let matcher = globset::GlobBuilder::new(glob)
.literal_separator(true)
@@ -3379,6 +3393,13 @@ impl PluginWorkspace for HostWorkspace {
})
}
fn build_graph(&self, root: &Path) -> Result<super::BuildGraph, HostError> {
let host = self.0.upgrade().ok_or(HostError::Cancelled)?;
let project = HostWorkspace::project_covering(self, root)
.ok_or_else(|| HostError::NotFound("the project is no longer open".into()))?;
crate::ops::build::analyzed_dependencies(&project, &host.config_dir, root).map_err(failed)
}
fn trusted(&self, root: &Path) -> bool {
// A workspace member is as trusted as the group's project it was opened with.
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
+337
Переглянути файл
@@ -0,0 +1,337 @@
//! `build.dependencies`: the Dependency Analyzer's Maven / Gradle trees as the flat
//! list the plugin API passes (records can't nest), each module a root.
use ide_build::{GradleDependency, GradleReport, MavenDependency, MavenProject, Omission};
use ide_plugin::{DependencyNode, DependencyStatus, HostError};
/// Most nodes one call returns.
const MAX_NODES: usize = 100_000;
/// What the IDE has resolved of a project's builds, without running a build tool.
#[derive(Clone, Debug, Default)]
pub struct BuildGraph {
/// Maven modules with their dependencies (with the transitive ones after a sync).
pub maven: Vec<MavenProject>,
pub gradle: Vec<GradleModule>,
}
/// A Gradle project and the reports the Dependency Analyzer read for it.
#[derive(Clone, Debug, Default)]
pub struct GradleModule {
/// Gradle path (`:`, `:app`).
pub path: String,
/// One per configuration read.
pub reports: Vec<GradleReport>,
}
/// The graph of `module` (a Maven `groupId:artifactId` or a Gradle path), or of every module.
pub fn dependency_nodes(graph: &BuildGraph, module: Option<&str>) -> Result<Vec<DependencyNode>, HostError> {
let mut out = Nodes(Vec::new());
let mut found = false;
for p in graph.maven.iter().filter(|p| module.is_none_or(|m| m == p.key())) {
found = true;
let root = out.push(DependencyNode {
group: p.group_id.clone(),
artifact: p.artifact_id.clone(),
version: p.version.clone(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
out.maven(&p.dependencies, root)?;
}
for g in graph.gradle.iter().filter(|g| module.is_none_or(|m| m == g.path)) {
found = true;
let root = out.push(DependencyNode {
group: String::new(),
artifact: g.path.clone(),
version: String::new(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
for report in &g.reports {
out.gradle(&report.dependencies, &report.configuration, root)?;
}
}
match module {
Some(m) if !found => Err(HostError::NotFound(format!("no Maven or Gradle module `{m}` in this project"))),
_ => Ok(out.0),
}
}
struct Nodes(Vec<DependencyNode>);
impl Nodes {
fn push(&mut self, node: DependencyNode) -> Result<u32, HostError> {
if self.0.len() >= MAX_NODES {
return Err(HostError::Failed(format!(
"the dependency graph has more than {MAX_NODES} nodes; ask for one module"
)));
}
self.0.push(node);
Ok((self.0.len() - 1) as u32)
}
fn maven(&mut self, deps: &[MavenDependency], parent: u32) -> Result<(), HostError> {
for d in deps {
let version = d.version.clone().unwrap_or_default();
let (status, version, requested) = match d.omitted {
// `version` lost to `conflict_with`.
Some(Omission::Conflict) => (
DependencyStatus::OmittedForConflict,
d.conflict_with.clone().unwrap_or_else(|| version.clone()),
Some(version),
),
Some(Omission::Duplicate | Omission::Cycle) => {
(DependencyStatus::OmittedForDuplicate, version, d.managed_from.clone())
}
None if d.managed_from.is_some() => (DependencyStatus::VersionManaged, version, d.managed_from.clone()),
None => (DependencyStatus::Resolved, version, None),
};
let index = self.push(DependencyNode {
group: d.group_id.clone(),
artifact: d.artifact_id.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: d.scope.clone(),
status,
parent: Some(parent),
})?;
self.maven(&d.children, index)?;
}
Ok(())
}
fn gradle(&mut self, deps: &[GradleDependency], configuration: &str, parent: u32) -> Result<(), HostError> {
// A constraint is not a dependency: it occurs as one elsewhere in the tree.
for d in deps.iter().filter(|d| !d.constraint) {
let (status, version, requested) = if d.project || d.unresolved {
(DependencyStatus::Resolved, String::new(), None)
} else {
match (&d.requested, &d.selected) {
(_, None) => (DependencyStatus::Resolved, d.requested.clone().unwrap_or_default(), None),
// A platform or a constraint supplies the version.
(None, Some(selected)) => (DependencyStatus::VersionManaged, selected.clone(), None),
// Conflict resolution picked another version than this exact request.
(Some(requested), Some(selected)) if exact_version(requested) => {
(DependencyStatus::OmittedForConflict, selected.clone(), Some(requested.clone()))
}
// A range or a rich version (`1.+`, `{strictly 2.0}`) resolved as asked.
(Some(requested), Some(selected)) => {
(DependencyStatus::Resolved, selected.clone(), Some(requested.clone()))
}
}
};
let status = if d.repeated && status == DependencyStatus::Resolved {
DependencyStatus::OmittedForDuplicate
} else {
status
};
let index = self.push(DependencyNode {
group: d.group.clone(),
artifact: d.name.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: configuration.to_owned(),
status,
parent: Some(parent),
})?;
self.gradle(&d.children, configuration, index)?;
}
Ok(())
}
}
/// `1.2.3`, not a range, dynamic or rich version (`[1,2)`, `1.+`, `latest.release`, `{strictly 1}`).
fn exact_version(v: &str) -> bool {
!v.is_empty() && !v.starts_with("latest.") && !v.contains(['[', ']', '(', ')', ',', '+', '{', '}', ' '])
}
#[cfg(test)]
mod tests {
use super::*;
fn maven(group: &str, artifact: &str, version: &str, scope: &str) -> MavenDependency {
MavenDependency {
group_id: group.into(),
artifact_id: artifact.into(),
version: Some(version.into()),
kind: "jar".into(),
scope: scope.into(),
..Default::default()
}
}
fn gradle(group: &str, name: &str, requested: Option<&str>, selected: Option<&str>) -> GradleDependency {
GradleDependency {
group: group.into(),
name: name.into(),
requested: requested.map(Into::into),
selected: selected.map(Into::into),
..Default::default()
}
}
/// (group, artifact, version, scope, status, requested, parent) of every node.
type Row<'a> = (&'a str, &'a str, &'a str, &'a str, DependencyStatus, Option<&'a str>, Option<u32>);
fn rows(nodes: &[DependencyNode]) -> Vec<Row<'_>> {
nodes
.iter()
.map(|n| {
(
n.group.as_str(),
n.artifact.as_str(),
n.version.as_str(),
n.scope.as_str(),
n.status,
n.requested_version.as_deref(),
n.parent,
)
})
.collect()
}
fn graph() -> BuildGraph {
let mut lang3_lost = maven("org.apache.commons", "commons-lang3", "3.12.0", "compile");
lang3_lost.omitted = Some(Omission::Conflict);
lang3_lost.conflict_with = Some("3.14.0".into());
let mut text = maven("org.apache.commons", "commons-text", "1.11.0", "compile");
text.children = vec![lang3_lost];
let mut logging = maven("commons-logging", "commons-logging", "1.3.0", "compile");
logging.managed_from = Some("1.2".into());
let mut junit_again = maven("junit", "junit", "4.13.2", "test");
junit_again.omitted = Some(Omission::Duplicate);
let mut hamcrest = maven("org.hamcrest", "hamcrest", "2.2", "test");
hamcrest.children = vec![junit_again];
let app = MavenProject {
group_id: "com.example".into(),
artifact_id: "app".into(),
version: "1.0".into(),
dependencies: vec![
maven("org.apache.commons", "commons-lang3", "3.14.0", "compile"),
text,
logging,
hamcrest,
],
..Default::default()
};
let mut databind = gradle("com.fasterxml.jackson.core", "jackson-databind", Some("2.15.0"), Some("2.15.3"));
databind.repeated = true;
let mut web = gradle("org.springframework.boot", "spring-boot-starter-web", None, Some("3.2.0"));
web.children = vec![databind];
let mut constraint = gradle("com.google.guava", "guava", Some("32.1.3-jre"), None);
constraint.constraint = true;
let mut core = gradle("", ":core", None, None);
core.project = true;
core.children = vec![constraint];
let mut failed = gradle("org.missing", "gone", Some("9"), None);
failed.unresolved = true;
let report = GradleReport {
project: ":web".into(),
configuration: "runtimeClasspath".into(),
dependencies: vec![
web,
core,
gradle("org.slf4j", "slf4j-api", Some("2.+"), Some("2.0.13")),
gradle("org.yaml", "snakeyaml", Some("2.2"), None),
failed,
],
};
BuildGraph {
maven: vec![app],
gradle: vec![
GradleModule { path: ":web".into(), reports: vec![report] },
GradleModule { path: ":".into(), reports: Vec::new() },
],
}
}
#[test]
fn modules_are_roots_with_their_trees_flattened_under_them() {
use DependencyStatus::*;
let nodes = dependency_nodes(&graph(), None).unwrap();
assert_eq!(
rows(&nodes),
[
("com.example", "app", "1.0", "", Resolved, None, None),
("org.apache.commons", "commons-lang3", "3.14.0", "compile", Resolved, None, Some(0)),
("org.apache.commons", "commons-text", "1.11.0", "compile", Resolved, None, Some(0)),
(
"org.apache.commons",
"commons-lang3",
"3.14.0",
"compile",
OmittedForConflict,
Some("3.12.0"),
Some(2)
),
("commons-logging", "commons-logging", "1.3.0", "compile", VersionManaged, Some("1.2"), Some(0)),
("org.hamcrest", "hamcrest", "2.2", "test", Resolved, None, Some(0)),
("junit", "junit", "4.13.2", "test", OmittedForDuplicate, None, Some(5)),
("", ":web", "", "", Resolved, None, None),
(
"org.springframework.boot",
"spring-boot-starter-web",
"3.2.0",
"runtimeClasspath",
VersionManaged,
None,
Some(7)
),
(
"com.fasterxml.jackson.core",
"jackson-databind",
"2.15.3",
"runtimeClasspath",
OmittedForConflict,
Some("2.15.0"),
Some(8)
),
("", ":core", "", "runtimeClasspath", Resolved, None, Some(7)),
("org.slf4j", "slf4j-api", "2.0.13", "runtimeClasspath", Resolved, Some("2.+"), Some(7)),
("org.yaml", "snakeyaml", "2.2", "runtimeClasspath", Resolved, None, Some(7)),
("org.missing", "gone", "", "runtimeClasspath", Resolved, None, Some(7)),
("", ":", "", "", Resolved, None, None),
]
);
}
#[test]
fn one_module_by_its_maven_key_or_gradle_path() {
let maven = dependency_nodes(&graph(), Some("com.example:app")).unwrap();
assert_eq!((maven.len(), maven[0].artifact.as_str()), (7, "app"));
let gradle = dependency_nodes(&graph(), Some(":web")).unwrap();
assert_eq!((gradle.len(), gradle[0].artifact.as_str(), gradle[1].parent), (7, ":web", Some(0)));
// A Gradle project with no report read yet is known, with nothing under it.
assert_eq!(dependency_nodes(&graph(), Some(":")).unwrap().len(), 1);
let err = dependency_nodes(&graph(), Some("app")).unwrap_err();
assert!(matches!(err, HostError::NotFound(_)), "{err:?}");
assert!(dependency_nodes(&BuildGraph::default(), None).unwrap().is_empty());
}
#[test]
fn a_graph_too_large_for_one_call_fails() {
let app = MavenProject {
group_id: "g".into(),
artifact_id: "a".into(),
dependencies: vec![maven("g", "d", "1", "compile"); MAX_NODES],
..Default::default()
};
let graph = BuildGraph { maven: vec![app], gradle: Vec::new() };
assert!(matches!(dependency_nodes(&graph, None), Err(HostError::Failed(_))));
}
#[test]
fn exact_versions() {
for v in ["1.0", "32.1.3-jre", "2.15.0"] {
assert!(exact_version(v), "{v}");
}
for v in ["", "1.+", "[1.0,2.0)", "latest.release", "{strictly 1.0}"] {
assert!(!exact_version(v), "{v}");
}
}
}
+45 -4
Переглянути файл
@@ -91,12 +91,31 @@ fn diff_side(value: &str, side: &str) -> Result<(), HostError> {
}
pub(super) fn validate_diff(diff: &ide_plugin::ContentDiff) -> Result<(), HostError> {
diff_side(&diff.left, "left")?;
diff_side(&diff.right, "right")?;
for value in [&diff.left_label, &diff.right_label].into_iter().flatten() {
validate_diff_parts([Some(&diff.left), Some(&diff.right)], [&diff.left_label, &diff.right_label], &diff.title)
}
/// A `None` side doesn't exist (an added or deleted file); at least one side does.
pub(super) fn validate_file_diff(diff: &ide_plugin::FileDiff) -> Result<(), HostError> {
validate_diff_parts([diff.left.as_ref(), diff.right.as_ref()], [&diff.left_label, &diff.right_label], &diff.title)
}
fn validate_diff_parts(
sides: [Option<&String>; 2],
labels: [&Option<String>; 2],
title: &Option<String>,
) -> Result<(), HostError> {
if sides.iter().all(Option::is_none) {
return Err(HostError::Invalid("a diff needs at least one side".into()));
}
for (value, side) in sides.into_iter().zip(["left", "right"]) {
if let Some(value) = value {
diff_side(value, side)?;
}
}
for value in labels.into_iter().flatten() {
label(value, 128)?;
}
if let Some(title) = &diff.title {
if let Some(title) = title {
label(title, 256)?;
}
Ok(())
@@ -713,6 +732,28 @@ mod tests {
);
}
#[test]
fn a_file_diff_may_miss_one_side_but_not_both() {
let side = |left: Option<&str>, right: Option<&str>| ide_plugin::FileDiff {
left: left.map(Into::into),
right: right.map(Into::into),
..Default::default()
};
assert!(validate_file_diff(&side(None, Some("added\n"))).is_ok());
assert!(validate_file_diff(&side(Some("deleted\n"), None)).is_ok());
assert!(validate_file_diff(&side(Some(""), Some(""))).is_ok());
assert!(
matches!(validate_file_diff(&side(None, None)), Err(HostError::Invalid(m)) if m == "a diff needs at least one side")
);
let huge = "y".repeat(MAX_DIFF_SIDE + 1);
assert!(
matches!(validate_file_diff(&side(None, Some(&huge))), Err(HostError::Invalid(m)) if m == "diff too large: the right side is over 8 MiB")
);
assert!(
matches!(validate_file_diff(&side(Some("a\0"), None)), Err(HostError::Invalid(m)) if m.contains("NUL"))
);
}
fn launch(
env: Vec<(&str, &str)>,
debugger: Option<ide_plugin::PluginDebugger>,
+250
Переглянути файл
@@ -0,0 +1,250 @@
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
//! JVM of Application, Spring Boot and JAR Application configurations.
//!
//! ```toml
//! [[contributes.javaAgents]]
//! path = "agent/openidea-spring-agent.jar" # inside the package
//! args = "optional-arguments" # optional
//! ```
//!
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
//! capability; granting it records the jar's hash, and a launch adds the agent only
//! while the jar still has it ([`ide_run::java_agent`]).
use ide_extension::{Capability, Disposable, ExtensionPoint, Manifest, Package, Placement, Prepared, decode};
use ide_language::ProgramPin;
use ide_run::java_agent::{ContributedAgent, JavaAgentSource};
use parking_lot::RwLock;
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
pub const POINT_ID: &str = "javaAgents";
const MAX_ARGS: usize = 4096;
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct Decl {
path: PathBuf,
#[serde(default)]
args: Option<String>,
}
#[derive(Clone, Debug)]
struct Agent {
/// The jar, resolved inside the package.
jar: PathBuf,
args: Option<String>,
}
/// Agents of enabled plugins.
#[derive(Default)]
pub struct JavaAgents {
items: RwLock<Vec<(u64, String, Agent)>>,
seq: AtomicU64,
}
impl JavaAgents {
fn add(self: &Arc<Self>, plugin: String, agent: Agent) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, plugin, agent));
let weak = Arc::downgrade(self);
Disposable::new(move || {
if let Some(this) = weak.upgrade() {
this.items.write().retain(|(s, _, _)| *s != seq);
}
})
}
}
pub struct JavaAgentsPoint {
store: Arc<JavaAgents>,
}
impl JavaAgentsPoint {
pub fn new(store: Arc<JavaAgents>) -> Self {
Self { store }
}
}
impl ExtensionPoint for JavaAgentsPoint {
fn id(&self) -> &'static str {
POINT_ID
}
fn placement(&self) -> Placement {
Placement::Workspace
}
fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
pkg.manifest.needs_api("contributes.javaAgents", 10)?;
if pkg.manifest.declarations(POINT_ID).len() > 1 {
return Err("contributes.javaAgents: a plugin contributes at most one Java agent".into());
}
let d: Decl = decode(POINT_ID, decl)?;
let jar = resolve(&pkg.dir, &d.path)?;
let args = d.args.filter(|a| !a.is_empty());
if let Some(args) = &args
&& (args.len() > MAX_ARGS || args.contains(|c: char| c.is_control()))
{
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
}
let label = label(&d.path, args.as_deref());
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
let agent = Agent { jar, args };
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
}
}
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
fn label(path: &Path, args: Option<&str>) -> String {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
match args {
Some(args) => format!("{name}={args}"),
None => name,
}
}
/// The jar a package's declaration names, as an absolute path inside the package:
/// `..`, absolute paths and symlinks that lead out of it are refused.
fn resolve(dir: &Path, rel: &Path) -> Result<PathBuf, String> {
ide_extension::check_relative(rel, "contributes.javaAgents: `path`")?;
let root = dunce::canonicalize(dir).map_err(|e| format!("plugin directory: {e}"))?;
let jar = dunce::canonicalize(dir.join(rel))
.map_err(|_| format!("contributes.javaAgents: {}: no such file in the plugin", rel.display()))?;
if !jar.starts_with(&root) {
return Err(format!("contributes.javaAgents: {}: points outside the plugin", rel.display()));
}
if !jar.is_file() {
return Err(format!("contributes.javaAgents: {}: not a file", rel.display()));
}
Ok(jar)
}
/// The jar the package at `dir` declares, for recording its hash when `java.agent`
/// is granted (before the declaration has taken effect, as on install).
pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
let decl = manifest.declarations(POINT_ID).into_iter().next()?;
let d: Decl = decode(POINT_ID, decl).ok()?;
resolve(dir, &d.path).ok()
}
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
pub struct PluginJavaAgents {
pub(super) store: Arc<JavaAgents>,
pub(super) pins: Pins,
}
impl JavaAgentSource for PluginJavaAgents {
fn agents(&self) -> Vec<ContributedAgent> {
let cap = Capability::JavaAgent.to_string();
let pins = self.pins.read();
self.store
.items
.read()
.iter()
.map(|(_, plugin, agent)| ContributedAgent {
plugin: plugin.clone(),
jar: agent.jar.clone(),
args: agent.args.clone(),
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
})
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
const MANIFEST: &str =
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
fn package(dir: &Path, manifest: &str) -> Package {
std::fs::create_dir_all(dir.join("agent")).unwrap();
std::fs::write(dir.join("agent/spring agent.jar"), b"PK").unwrap();
Package::new(Manifest::parse(manifest).unwrap(), dir.to_path_buf())
}
fn prepare(pkg: &Package) -> Result<Prepared, String> {
let point = JavaAgentsPoint::new(Arc::default());
let decls = pkg.manifest.declarations(POINT_ID);
let mut last = Err("no declaration".into());
for decl in decls {
last = Ok(point.prepare(pkg, decl)?);
}
last
}
#[test]
fn parses_the_declaration_and_derives_the_capability() {
let tmp = tempfile::tempdir().unwrap();
let toml = format!(
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"port=0,trace\"\n"
);
let pkg = package(tmp.path(), &toml);
let prepared = prepare(&pkg).unwrap();
assert_eq!(prepared.capabilities, [Capability::JavaAgent]);
assert_eq!(prepared.files, [PathBuf::from("agent/spring agent.jar")]);
assert_eq!(prepared.label, "spring agent.jar=port=0,trace");
let jar = declared_jar(&pkg.manifest, &pkg.dir).unwrap();
assert_eq!(jar, dunce::canonicalize(tmp.path().join("agent/spring agent.jar")).unwrap());
let store: Arc<JavaAgents> = Arc::default();
let point = JavaAgentsPoint::new(store.clone());
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
let disposable = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
let source = PluginJavaAgents { store: store.clone(), pins: Arc::default() };
let agents = source.agents();
assert_eq!(agents.len(), 1);
assert_eq!(
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
("acme.spring", Some("port=0,trace"), None)
);
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
assert!(source.agents()[0].approved_hash.is_some());
disposable.dispose();
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
}
#[test]
fn refuses_what_would_fail_at_launch() {
let tmp = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
std::fs::write(outside.path().join("evil.jar"), b"PK").unwrap();
let refused = |n: usize, manifest: &str| {
let dir = tmp.path().join(n.to_string());
prepare(&package(&dir, manifest)).map(|_| ()).unwrap_err()
};
let case = |n: usize, body: &str| refused(n, &format!("{MANIFEST}{body}"));
let agent = |path: &str| format!("[[contributes.javaAgents]]\npath = \"{path}\"\n");
assert!(case(0, &agent("../evil.jar")).contains("relative path inside the plugin"));
assert!(case(1, &agent("/etc/passwd")).contains("relative path inside the plugin"));
assert!(case(2, &agent("agent/missing.jar")).contains("no such file"));
assert!(case(3, &agent("agent")).contains("not a file"));
let two = format!("{}{}", agent("agent/spring agent.jar"), agent("agent/spring agent.jar"));
assert!(case(4, &two).contains("at most one Java agent"));
assert!(
case(5, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"a\\nb\"\n")
.contains("one line")
);
assert!(
case(6, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nmain = \"x\"\n")
.contains("unknown field")
);
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
assert!(refused(7, &old).contains("new in plugin API 1.10"));
#[cfg(unix)]
{
let dir = tmp.path().join("8");
let pkg = package(&dir, &format!("{MANIFEST}{}", agent("agent/link.jar")));
std::os::unix::fs::symlink(outside.path().join("evil.jar"), dir.join("agent/link.jar")).unwrap();
assert!(prepare(&pkg).map(|_| ()).unwrap_err().contains("points outside the plugin"));
assert_eq!(declared_jar(&pkg.manifest, &pkg.dir), None);
}
}
}
+34 -5
Переглянути файл
@@ -17,6 +17,7 @@
mod api;
mod auth;
mod build_graph;
pub mod commands;
pub mod commit;
mod database;
@@ -37,6 +38,7 @@ mod inlay_hints;
mod install;
pub mod intellij;
mod ipc;
mod java_agents;
pub mod language_features;
mod market;
mod mcp;
@@ -58,6 +60,7 @@ pub mod web;
mod websocket;
pub use api::{FileSecretStore, HostWorkspace, PluginWorkspace, SecretStore};
pub use build_graph::{BuildGraph, GradleModule};
pub(crate) use hover::merge as merge_hover;
pub use icons::{
MAX_PLUGIN_ICON, map_asset as icon_theme_map_asset, plugin_icon, sanitize_svg, svg_prefix as icon_theme_svg_prefix,
@@ -378,6 +381,8 @@ pub struct PluginHost {
ui: Arc<UiStore>,
languages: Arc<PluginLanguages>,
run_detectors: Arc<run_detectors::RunDetectors>,
/// `[[contributes.javaAgents]]` of enabled plugins.
java_agents: Arc<java_agents::JavaAgents>,
/// `[[contributes.providers]]` of enabled plugins.
providers: Arc<providers::Providers>,
navigation: Mutex<navigation::NavigationIndex>,
@@ -457,7 +462,9 @@ impl PluginHost {
let languages = PluginLanguages::new();
let run_detectors: Arc<run_detectors::RunDetectors> = Arc::default();
let providers: Arc<providers::Providers> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &providers).map_err(IdeError::internal)?;
let java_agents: Arc<java_agents::JavaAgents> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers)
.map_err(IdeError::internal)?;
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
let policy_pins = pins.clone();
languages.set_process_policy(Arc::new(move |plugin, cap| {
@@ -491,6 +498,7 @@ impl PluginHost {
ui,
languages,
run_detectors,
java_agents,
providers,
navigation: Mutex::default(),
endpoints: Mutex::default(),
@@ -991,8 +999,8 @@ impl PluginHost {
};
// Consent covers what the install page showed.
let request = request_for(&subject, &pkg.manifest, &hash, &set.capabilities);
self.record_consent(&request, consent);
let dir = install::active_dir(&root).ok_or_else(|| IdeError::internal("the installed version is missing"))?;
self.record_consent(&request, consent, agent_jar_grant(&pkg.manifest, &dir));
self.load_dir(&dir, PluginSource::Installed, None);
if let Some(previous) = previous {
let failed = self
@@ -1110,7 +1118,7 @@ impl PluginHost {
let hash = self.package_hash_of(&plugin);
let extra = plugin.meta.lock().declared_extra.clone();
let request = request_for(&plugin.subject(), plugin.manifest(), &hash, &extra);
self.record_consent(&request, consent);
self.record_consent(&request, consent, agent_jar_grant(plugin.manifest(), plugin.dir()));
self.stop(&plugin);
if !self.state.lock().disabled.contains(id) {
self.start(&plugin);
@@ -1160,6 +1168,12 @@ impl PluginHost {
return Err(IdeError::invalid(format!("plugin {id:?} has not been confirmed yet")));
}
ledger.set(&subject, &cap, granted);
if granted
&& cap == Capability::JavaAgent
&& let Some(jar) = agent_jar_grant(plugin.manifest(), plugin.dir())
{
ledger.set_binary(&subject, &cap, jar);
}
if granted
&& let Capability::Process(program) = &cap
&& let Some(bin) = ledger
@@ -1696,6 +1710,11 @@ impl PluginHost {
})
}
/// Plugins' `javaAgents`, for [`ide_run::java_agent::set_java_agent_source`].
pub fn java_agents(&self) -> Arc<dyn ide_run::java_agent::JavaAgentSource> {
Arc::new(java_agents::PluginJavaAgents { store: self.java_agents.clone(), pins: self.pins.clone() })
}
/// The syntax of plugin languages, for [`ide_language::set_external_syntax`].
pub fn syntax_provider(self: &Arc<Self>) -> Arc<dyn ide_language::ExternalSyntax> {
Arc::new(PluginSyntax(Arc::downgrade(self)))
@@ -2933,7 +2952,7 @@ impl PluginHost {
}
let declared =
plugin.manifest().capabilities.all().cloned().chain(plugin.meta.lock().declared_extra.clone());
for cap in declared.filter(|c| matches!(c, Capability::Process(_))) {
for cap in declared.filter(|c| matches!(c, Capability::Process(_) | Capability::JavaAgent)) {
if let Some(bin) = ledger.pinned_binary(&subject, &cap) {
pins.insert(
(plugin.id().to_owned(), cap.to_string()),
@@ -2994,7 +3013,9 @@ impl PluginHost {
self.save_ledger(&ledger);
}
fn record_consent(&self, request: &Request<'_>, consent: &Consent) {
/// `agent_jar`: the jar of the plugin's `javaAgents` declaration, recorded when
/// `java.agent` is accepted.
fn record_consent(&self, request: &Request<'_>, consent: &Consent, agent_jar: Option<BinaryGrant>) {
let accepted: Vec<Capability> = request.optional.iter().filter(|c| consent.accepts(c)).cloned().collect();
let choices: BTreeMap<_, _> = {
let ledger = self.ledger.lock();
@@ -3016,6 +3037,7 @@ impl PluginHost {
.get(&c.to_string())
.map_or_else(|| self.resolve_binary(program), |path| ledger::approve_program(path).ok())
.map(|b| (c.to_string(), b)),
Capability::JavaAgent => agent_jar.clone().map(|jar| (c.to_string(), jar)),
_ => None,
})
.collect();
@@ -3094,6 +3116,13 @@ impl Drop for PluginHost {
}
}
/// The jar of a package's `javaAgents` declaration with its hash now, for a `java.agent` grant.
fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
let path = java_agents::declared_jar(manifest, dir)?;
let hash = ledger::file_hash(&path).map_err(|e| tracing::info!("java.agent: {}: {e}", path.display())).ok()?;
Some(BinaryGrant { path, hash })
}
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
let mut optional = m.capabilities.optional.clone();
// What declarations need (a language server's `process:`) is optional:
+2
Переглянути файл
@@ -64,6 +64,7 @@ pub fn register_builtin_points(
ui: &Arc<UiStore>,
languages: &Arc<PluginLanguages>,
run_detectors: &Arc<super::run_detectors::RunDetectors>,
java_agents: &Arc<super::java_agents::JavaAgents>,
providers: &Arc<super::providers::Providers>,
) -> Result<(), String> {
registry.register(Arc::new(UiPoint::new(COMMANDS, ui.clone(), command)))?;
@@ -71,6 +72,7 @@ pub fn register_builtin_points(
registry.register(Arc::new(LanguagesPoint::new(languages.clone())))?;
registry.register(Arc::new(UiPoint::new(super::icons::POINT_ID, ui.clone(), super::icons::icon_theme)))?;
registry.register(Arc::new(super::run_detectors::RunDetectorsPoint::new(run_detectors.clone())))?;
registry.register(Arc::new(super::java_agents::JavaAgentsPoint::new(java_agents.clone())))?;
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
+1 -1
Переглянути файл
@@ -220,7 +220,7 @@ pub enum PluginEvent {
ContentTabReply { plugin_id: String, request_id: String, reply: ide_plugin::ContentTabReply },
/// Open two texts in this window's diff viewer.
#[serde(rename_all = "camelCase")]
OpenDiff { plugin_id: String, diff: ide_plugin::ContentDiff, file_name: Option<String> },
OpenDiff { plugin_id: String, diff: ide_plugin::FileDiff, file_name: Option<String> },
/// Plugins, their status or their contributions changed: re-fetch `plugin_list`.
CommandsChanged,
+57 -23
Переглянути файл
@@ -112,7 +112,7 @@ impl Host {
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
let extra_roots = content_roots(&settings.effective(), &root, &build_cache);
let extra_roots = content_roots(&settings.effective(), &root, &build_cache, trusted.load(Ordering::Acquire));
mark("roots");
// The project's own registry: File Types associations may be project-scoped.
@@ -147,7 +147,9 @@ impl Host {
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&settings.effective().languages.java.maven.linked_projects,
&build_cache,
&settings.effective().languages.java.maven,
trusted.load(Ordering::Acquire),
));
let settings = Arc::new(settings);
{
@@ -415,7 +417,10 @@ impl Host {
// Detected excluded folders (`target`, `build`) leave the index too.
let effective = settings.effective();
index.set_scope(
index_roots(&root, content_roots(&effective, &root, &build_cache)),
index_roots(
&root,
content_roots(&effective, &root, &build_cache, trusted.load(Ordering::Acquire)),
),
exclude_globs(&root, &effective, &fresh),
);
*detected_roots.write() = fresh;
@@ -458,7 +463,14 @@ impl Host {
// through the `.git` paths above; this covers the whole tree being brought in.
git_dirs |= batch.created.iter().any(|p| p.join(".git").exists());
if git_dirs {
scan_repositories(&root, &repos, &settings, &sink, &build_cache);
scan_repositories(
&root,
&repos,
&settings,
&sink,
&build_cache,
trusted.load(Ordering::Acquire),
);
}
let vcs_moved = batch.vcs.iter().any(|p| vcs_path_changed(p));
if git_dirs || vcs_moved {
@@ -544,9 +556,10 @@ impl Host {
{
let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());
let build_cache = build_cache.clone();
let trusted = trusted.load(Ordering::Acquire);
std::thread::Builder::new()
.name("openidea-vcs-roots".into())
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache))?;
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache, trusted))?;
}
mark("git");
tracing::info!("opened {} in window {window} in {} ms {laps:?}", root.display(), started.elapsed().as_millis());
@@ -907,8 +920,9 @@ fn scan_repositories(
settings: &SettingsStore,
sink: &SharedSink,
build_cache: &Path,
trusted: bool,
) {
match discover_repositories(root, settings, build_cache) {
match discover_repositories(root, settings, build_cache, trusted) {
Ok(found) => {
if found.roots() != repos.read().roots() {
*repos.write() = found;
@@ -921,7 +935,7 @@ fn scan_repositories(
/// The repository containing `root` and those nested below it or below a content root.
/// The project-open scan and the watcher's rescan share these skip rules.
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path) -> IdeResult<Repos> {
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
let ignored = settings.effective().ignored_names();
let skip = |p: &Path| {
p.file_name().is_some_and(|n| {
@@ -932,13 +946,20 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
})
};
let mut roots = vec![root.to_path_buf()];
roots.extend(content_roots(&settings.effective(), root, build_cache));
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
Repos::discover_roots(&roots, &skip)
}
impl Project {
pub fn refresh_repositories(&self) {
scan_repositories(&self.root, &self.repos, &self.settings, &self.sink, &self.build_cache_dir());
scan_repositories(
&self.root,
&self.repos,
&self.settings,
&self.sink,
&self.build_cache_dir(),
self.is_trusted(),
);
}
/// The project's git repositories.
@@ -1204,7 +1225,7 @@ impl Project {
/// Project Structure content roots besides the project folder (existing directories).
pub fn content_roots(&self) -> Vec<PathBuf> {
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir())
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir(), self.is_trusted())
}
/// Applies Settings › File Types; open documents whose language changed are
@@ -1228,7 +1249,9 @@ impl Project {
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.settings.effective().languages.java.maven.linked_projects,
&self.build_cache_dir(),
&self.settings.effective().languages.java.maven,
self.is_trusted(),
));
self.index.set_scope(index_roots(&self.root, roots.clone()), excludes.clone());
self.watcher.set_excludes(&excludes);
@@ -1354,8 +1377,14 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
/// Workspace members in manifest order, or the attached projects outside the project and
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
/// extra Project Structure directories, Gradle project folders outside the project, and
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
/// directories of Maven POMs linked from outside it and, when `trusted`, of the Maven reactor's
/// modules there (`build_cache` holds the Gradle and Maven sync results).
fn content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
build_cache: &Path,
trusted: bool,
) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
if workspace.is_container(root) {
return workspace.projects;
@@ -1365,14 +1394,14 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
.into_iter()
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
.collect::<Vec<_>>();
for path in extra_content_roots(settings, root, build_cache) {
for path in extra_content_roots(settings, root, build_cache, trusted) {
if !roots.contains(&path) {
roots.push(path);
}
}
return roots;
}
extra_content_roots(settings, root, build_cache)
extra_content_roots(settings, root, build_cache, trusted)
}
/// The content roots plus the projects attached inside this one. The index covers those
@@ -1439,7 +1468,7 @@ fn navigation_roots_uncached(project: &Project, from: &Path) -> Vec<PathBuf> {
}
}
if workspace.is_none() {
for root in content_roots(&settings, &project.root, &project.build_cache_dir()) {
for root in content_roots(&settings, &project.root, &project.build_cache_dir(), project.is_trusted()) {
if !roots.contains(&root) {
roots.push(root);
}
@@ -1458,7 +1487,12 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
}
fn extra_content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
fn extra_content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
build_cache: &Path,
trusted: bool,
) -> Vec<PathBuf> {
let mut out: Vec<PathBuf> = Vec::new();
let user = settings
.project_structure
@@ -1468,7 +1502,7 @@ fn extra_content_roots(settings: &ide_core::settings::Settings, root: &Path, bui
.map(|r| PathBuf::from(r.trim()));
for p in user
.chain(ide_build::gradle_external_roots(root, build_cache, &settings.languages.java.gradle))
.chain(ide_build::maven_external_roots(root, &settings.languages.java.maven.linked_projects))
.chain(ide_build::maven_external_roots(root, build_cache, &settings.languages.java.maven, trusted))
{
if p.is_absolute() && p.is_dir() && !p.starts_with(root) && !out.contains(&p) {
out.push(p);
@@ -1954,11 +1988,11 @@ mod maven_linkage_tests {
}
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = vec!["../B/pom.xml".into()];
assert_eq!(super::content_roots(&settings, &a, &base.join("cache")), vec![b]);
assert_eq!(super::content_roots(&settings, &a, &base.join("cache"), false), vec![b]);
// External links must not replace jdtls's scan of the opened root with a build-file list.
assert_eq!(super::jdtls_maven_import(&a, &settings), (Vec::new(), None));
settings.languages.java.maven.linked_projects.clear();
assert!(super::content_roots(&settings, &a, &base.join("cache")).is_empty());
assert!(super::content_roots(&settings, &a, &base.join("cache"), false).is_empty());
}
#[test]
@@ -2182,7 +2216,7 @@ mod content_roots_tests {
settings.project_structure.content_roots = vec![shared.to_string_lossy().into_owned()];
settings.project_structure.dependencies =
vec![dep.to_string_lossy().into_owned(), root.to_string_lossy().into_owned()];
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
let roots = content_roots(&settings, &root, &tmp.path().join("build"), false);
assert_eq!(roots, vec![shared, dep]);
}
@@ -2196,12 +2230,12 @@ mod content_roots_tests {
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build, false)).is_empty());
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
.unwrap();
// The index walks the nested project as part of the root ...
let roots = content_roots(&settings, &root, &build);
let roots = content_roots(&settings, &root, &build, false);
assert_eq!(roots, vec![other.clone()]);
// ... while its files go to a language server of its own.
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
+9 -1
Переглянути файл
@@ -245,10 +245,18 @@ impl crate::Host {
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
for project in self.projects().into_iter().filter(|p| !p.light) {
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
let roots = project.content_roots();
let previous = project.trusted.swap(trusted, std::sync::atomic::Ordering::AcqRel);
if previous == trusted {
continue;
}
// Maven reactor modules outside the project are content roots of a trusted project only.
if project.content_roots() != roots {
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.schedule();
}
@@ -324,6 +332,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "doc_edit"
| "doc_folding"
| "doc_highlights"
| "doc_language"
| "doc_open"
| "doc_open_untitled"
| "doc_open_virtual"
@@ -338,7 +347,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "doc_set_line_ending"
| "doc_snapshot"
| "doc_sync_from_disk"
| "doc_ui_mode"
| "syntax_errors"
| "syntax_expression_at"
| "syntax_identifiers"
+2 -2
Переглянути файл
@@ -68,7 +68,7 @@ done
}
for _ in 0..20 {
for window in ["first", "second"] {
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(state.refreshing);
}
}
@@ -87,7 +87,7 @@ done
assert!(completed.is_ok(), "both windows must receive the completed catalog");
for _ in 0..20 {
for window in ["first", "second"] {
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
assert!(!catalog.refreshing);
assert!(catalog.retry_at_ms.is_some());
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
+44
Переглянути файл
@@ -69,3 +69,47 @@ async fn external_maven_link_persists_reloads_and_unlink_keeps_files() {
assert_eq!(std::fs::read_to_string(sibling.join("pom.xml")).unwrap(), b_pom);
host.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn reactor_module_beside_a_trusted_project_is_a_content_root_until_removed() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("aggregator");
let service = base.join("service-a");
std::fs::create_dir_all(root.join("core")).unwrap();
std::fs::create_dir_all(&service).unwrap();
let reactor = |modules: &str| {
format!(
"<project><artifactId>aggregator</artifactId><packaging>pom</packaging><modules>{modules}</modules></project>"
)
};
std::fs::write(root.join("pom.xml"), reactor("<module>core</module><module>../service-a</module>")).unwrap();
std::fs::write(root.join("core/pom.xml"), "<project><artifactId>core</artifactId></project>").unwrap();
std::fs::write(service.join("pom.xml"), "<project><artifactId>service-a</artifactId></project>").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |window| window,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.open_project("main", &root).unwrap();
let project = || host.project("main").unwrap();
assert!(project().content_roots().is_empty(), "Restricted Mode does not widen the index");
assert!(project().lsp.jdtls_import_roots().is_empty());
host.set_project_trust(&root, true, false).await.unwrap();
assert_eq!(project().content_roots(), vec![service.clone()]);
assert_eq!(project().lsp.jdtls_import_roots(), vec![service.clone()]);
std::fs::write(root.join("pom.xml"), reactor("<module>core</module>")).unwrap();
project().refresh_index_scope();
assert!(project().content_roots().is_empty());
assert!(project().lsp.jdtls_import_roots().is_empty());
assert!(service.join("pom.xml").is_file());
host.shutdown().await;
}
+5 -1
Переглянути файл
@@ -131,9 +131,13 @@ async fn returns_all_python_classes_and_bases() {
// Every returned entry is a Python file.
assert!(all.iter().all(|c| { matches!(c.path.0.extension().and_then(|e| e.to_str()), Some("py" | "pyi")) }));
// A file changed on disk is parsed again; the others come from the cache.
// A file changed on disk is picked up once the index re-reads it. The index is the
// single source of truth for on-disk classes now; edits go through its update path
// (the IDE's file watcher calls this in production).
let extra = p.root.join("src/extra.pyi");
std::fs::write(&extra, "class Stub(Child): ...\nclass Added(Base): ...\n").unwrap();
p.host.project(WINDOW).unwrap().index.update(std::slice::from_ref(&extra), &[]);
assert!(p.host.project(WINDOW).unwrap().index.wait_idle(Duration::from_secs(5)));
let again = ops::nav::nav_inheritance(&p.host, WINDOW).await.unwrap();
assert_eq!(find(&again, "Stub").bases, vec!["Child".to_string()]);
assert_eq!(find(&again, "Added").bases, vec!["Base".to_string()]);
+1
Переглянути файл
@@ -54,6 +54,7 @@ fn method() -> SymbolTag {
kind: SymbolKind::Method,
container: None,
range: Range::new(Pos::new(0, 4), Pos::new(0, 8)),
bases: Vec::new(),
}
}
const SOURCE: &str = "def source:item\nref mapping:item\n";
+1
Переглянути файл
@@ -225,6 +225,7 @@ async fn indexed_usages_rename_preview_staleness_and_grouped_undo() {
kind: ide_core::SymbolKind::Method,
container: None,
range: ide_core::Range::new(Pos::new(0, 4), Pos::new(0, 5)),
bases: Vec::new(),
};
plugins
.index_navigation(
+144 -2
Переглянути файл
@@ -196,6 +196,41 @@ impl PluginWorkspace for TestWorkspace {
self.server_messages.lock().push((method.into(), params.clone(), notify));
Ok(if notify { serde_json::Value::Null } else { serde_json::json!({ "method": method, "params": params }) })
}
/// A Maven module with a lost version conflict, and a Gradle project with one report.
fn build_graph(&self, _root: &Path) -> Result<BuildGraph, HostError> {
let dep = |artifact: &str, version: &str| ide_build::MavenDependency {
group_id: "org.apache.commons".into(),
artifact_id: artifact.into(),
version: Some(version.into()),
scope: "compile".into(),
..Default::default()
};
let mut text = dep("commons-text", "1.11.0");
text.children = vec![ide_build::MavenDependency {
omitted: Some(ide_build::Omission::Conflict),
conflict_with: Some("3.14.0".into()),
..dep("commons-lang3", "3.12.0")
}];
let app = ide_build::MavenProject {
group_id: "com.example".into(),
artifact_id: "app".into(),
version: "1.0".into(),
dependencies: vec![text],
..Default::default()
};
let snakeyaml = ide_build::GradleDependency {
group: "org.yaml".into(),
name: "snakeyaml".into(),
requested: Some("2.2".into()),
..Default::default()
};
let report = ide_build::GradleReport {
project: ":web".into(),
configuration: "runtimeClasspath".into(),
dependencies: vec![snakeyaml],
};
Ok(BuildGraph { maven: vec![app], gradle: vec![GradleModule { path: ":web".into(), reports: vec![report] }] })
}
fn project_windows(&self, root: &Path) -> Vec<String> {
// `main` shows the fixture project; other open roots have no window left.
if root == self.root { vec!["closing".into(), "main".into()] } else { Vec::new() }
@@ -2151,6 +2186,60 @@ fn run_detectors_offer_granted_commands_in_marked_projects() {
assert!(detection.launch(config).unwrap_err().contains("no longer enabled"));
}
/// A plugin's Java agent (`[[contributes.javaAgents]]`, the `java-agent` fixture): an optional
/// high-risk `java.agent` capability; refusing or revoking it keeps the plugin working and the
/// launch gets no agent; granting it pins the jar, which may not change afterwards.
#[test]
fn java_agent_loads_only_while_granted_and_unchanged() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("java-agent");
copy_dir(&sample("java-agent"), &pkg);
let preview = f.host.preview_install(&pkg).unwrap();
let cap = preview.capabilities.iter().find(|c| c.id == "java.agent").expect("derived from the declaration");
assert!(cap.optional && cap.risk == ide_extension::Risk::High && !cap.granted);
assert_eq!(cap.description, "Run code inside the Java applications you start");
// Refused on install: the plugin is on, Java launches get no agent.
let info = f.host.install_from_dir(&pkg, &Consent::default()).unwrap();
assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
assert!(info.contributions.iter().any(|c| c.point == "javaAgents" && c.label == "fixture agent.jar=mode=test"));
let source = f.host.java_agents();
let launch = || {
let agents = ide_run::java_agent::approved(&source.agents());
let mut args: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
ide_run::java_agent::add_to_args(&mut args, &agents.options);
(args, agents.notes)
};
let plain: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
assert_eq!(launch(), (plain.clone(), vec![]));
// Granted: the installed jar with its arguments, one argument after the VM options.
let info = f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(info.capabilities.iter().any(|c| c.id == "java.agent" && c.granted));
let jar = dunce::canonicalize(f.installed("java-agent").join("agent/fixture agent.jar")).unwrap();
let option = format!("-javaagent:{}=mode=test", jar.display());
let mut with_agent = plain.clone();
with_agent.insert(3, option.clone());
assert_eq!(launch(), (with_agent.clone(), vec![]));
// The jar changed since it was granted: left out, with a reason, until approved again.
std::fs::write(&jar, "swapped").unwrap();
let (args, notes) = launch();
assert_eq!(args, plain);
assert!(notes.len() == 1 && notes[0].contains("changed since it was approved"), "{notes:?}");
f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert_eq!(launch(), (with_agent.clone(), vec![]));
// Revoked, then the plugin disabled: no agent either way.
f.host.set_capability("java-agent", "java.agent", false).unwrap();
assert_eq!(f.status("java-agent"), PluginStatus::Static);
assert_eq!(launch(), (plain.clone(), vec![]));
f.host.set_capability("java-agent", "java.agent", true).unwrap();
f.host.set_enabled("java-agent", false).unwrap();
assert_eq!(launch(), (plain, vec![]));
}
/// Compiled components are cached across runs (keyed by module and
/// engine), so a cold activation only deserializes.
#[test]
@@ -6518,8 +6607,8 @@ fn a_plugin_command_opens_a_diff_in_its_window() {
client.as_deref() == Some("main")
&& matches!(event, PluginEvent::OpenDiff { plugin_id, diff, file_name }
if plugin_id == "execution"
&& diff.left == "before\n"
&& diff.right == "after\n"
&& diff.left.as_deref() == Some("before\n")
&& diff.right.as_deref() == Some("after\n")
&& diff.title.as_deref() == Some("Review")
&& file_name.as_deref() == Some("src/review.rs"))
})
@@ -7022,6 +7111,59 @@ fn the_language_server_grant_needs_api_1_9() {
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// `build.dependencies` hands a plugin the resolved Maven / Gradle graph as a flat list, each
/// module a root, with `build.read` in a trusted project (API 1.10).
#[test]
fn build_dependencies_need_the_grant_and_a_trusted_project() {
let f = fixture(Limits::default());
let id = "test.build-graph";
let info = f.install(&sample("build-graph"));
assert!(info.capabilities.iter().any(|c| c.id == "build.read" && c.granted && c.risk == ide_extension::Risk::Low));
// `parent group:artifact:version scope status requested`, as the fixture prints them.
assert_eq!(
f.run(id, "dependencies", None).unwrap().unwrap(),
"- com.example:app:1.0 resolved -\n\
0 org.apache.commons:commons-text:1.11.0 compile resolved -\n\
1 org.apache.commons:commons-lang3:3.14.0 compile conflict 3.12.0\n\
- ::web: resolved -\n\
3 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
);
assert_eq!(
f.run(id, "dependencies", Some(":web")).unwrap().unwrap(),
"- ::web: resolved -\n0 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
);
let err = f.host.run_command(id, "dependencies", Some("app"), f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::NotFound, "{err:?}");
f.host.set_capability(id, "build.read", false).unwrap();
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert!(err.message.contains("build.read"), "{err:?}");
f.host.set_capability(id, "build.read", true).unwrap();
// The graph comes from running the project's build: not in an untrusted project.
let mut untrusted = TestWorkspace::new(&f.project);
Arc::get_mut(&mut untrusted).unwrap().trusted = false;
f.host.set_workspace(Some(untrusted));
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert_eq!(f.host.info_of(id).unwrap().stats.crashes, 0);
}
/// The grant is new in API 1.10: an older `engines.openidea` can't ask for it.
#[test]
fn the_build_grant_needs_api_1_10() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("build-graph");
copy_dir(&sample("build-graph"), &pkg);
let manifest = std::fs::read_to_string(pkg.join("plugin.toml")).unwrap();
std::fs::write(pkg.join("plugin.toml"), manifest.replace("\"^1.10\"", "\"^1.9\"")).unwrap();
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.10"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
+44 -1
Переглянути файл
@@ -106,6 +106,9 @@ pub(crate) struct StoredSymbol {
pub kind: SymbolKind,
pub container: Option<String>,
pub range: Range,
/// Base names of a class definition; empty for every other symbol.
#[serde(default)]
pub bases: Vec<String>,
}
/// A symbol resolved out of [`SymTable`].
@@ -114,6 +117,8 @@ pub(crate) struct SymRef<'a> {
pub kind: SymbolKind,
pub container: Option<&'a str>,
pub range: Range,
/// Base names joined with `'\0'`; empty when the symbol has none.
pub bases: &'a str,
}
pub(crate) struct FileEntry {
@@ -402,6 +407,8 @@ pub(crate) struct SymTable {
container: Vec<Span>,
kind: Vec<SymbolKind>,
range: Vec<Range>,
/// Base names joined with `'\0'`, one interned span per symbol (`NONE` for none).
bases: Vec<Span>,
text: String,
dead_rows: usize,
}
@@ -423,6 +430,18 @@ impl SymTable {
(span.start != u32::MAX).then(|| span.get(&self.text))
}
/// The symbol's base names joined with `'\0'`; empty when it has none.
#[inline]
pub(crate) fn bases(&self, i: u32) -> &str {
let span = self.bases[i as usize];
if span.start == u32::MAX { "" } else { span.get(&self.text) }
}
/// The base names of row `i`, split out of the interned string.
pub(crate) fn base_list(&self, i: u32) -> Vec<&str> {
self.bases(i).split('\0').filter(|b| !b.is_empty()).collect()
}
/// The mask + name rows of a file's contiguous symbol range.
#[inline]
pub(crate) fn heads(&self, start: u32, len: u32) -> &[SymHead] {
@@ -459,10 +478,12 @@ impl SymTable {
Some(c) => self.intern(c),
None => Span::NONE,
};
let bases = if s.bases.is_empty() { Span::NONE } else { self.intern(&s.bases.join("\0")) };
self.head.push(SymHead { mask, name });
self.container.push(container);
self.kind.push(s.kind);
self.range.push(s.range);
self.bases.push(bases);
}
(start, agg_mask)
}
@@ -476,6 +497,7 @@ impl SymTable {
&& self.container(i) == s.container.as_deref()
&& self.kind(i) == s.kind
&& self.range(i) == s.range
&& self.base_list(i) == s.bases.iter().map(String::as_str).collect::<Vec<_>>()
})
}
@@ -492,6 +514,7 @@ impl SymTable {
let mut container = Vec::with_capacity(head.capacity());
let mut kind = Vec::with_capacity(head.capacity());
let mut range = Vec::with_capacity(head.capacity());
let mut bases = Vec::with_capacity(head.capacity());
let mut live = 0u32;
for (slot, row) in rows.iter_mut().enumerate() {
if !row.live {
@@ -518,6 +541,14 @@ impl SymTable {
}
kind.push(self.kind[i as usize]);
range.push(self.range[i as usize]);
let bases_span = self.bases[i as usize];
if bases_span.start == u32::MAX {
bases.push(Span::NONE);
} else {
let b = bases_span.get(&self.text);
bases.push(Span::of(&text, b));
text.push_str(b);
}
live += 1;
}
}
@@ -525,6 +556,7 @@ impl SymTable {
self.container = container;
self.kind = kind;
self.range = range;
self.bases = bases;
self.text = text;
self.dead_rows = 0;
}
@@ -534,6 +566,7 @@ impl SymTable {
self.container.shrink_to_fit();
self.kind.shrink_to_fit();
self.range.shrink_to_fit();
self.bases.shrink_to_fit();
self.text.shrink_to_fit();
}
}
@@ -577,6 +610,7 @@ impl IndexData {
self.syms.container.reserve(symbols);
self.syms.kind.reserve(symbols);
self.syms.range.reserve(symbols);
self.syms.bases.reserve(symbols);
}
/// Hydrates a validated warm-start snapshot in one pass, without per-file
@@ -640,6 +674,7 @@ impl IndexData {
kind: s.kind,
container: s.container.map(str::to_owned),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
})
.collect(),
ignored: e.ignored,
@@ -666,6 +701,7 @@ impl IndexData {
kind: syms.kind(i),
container: syms.container(i),
range: syms.range(i),
bases: syms.bases(i),
})
}
@@ -823,6 +859,7 @@ mod tests {
kind: SymbolKind::Function,
container: None,
range: Range::default(),
bases: Vec::new(),
})
.collect(),
..Default::default()
@@ -957,7 +994,13 @@ mod tests {
}
fn symbol(n: &str) -> StoredSymbol {
StoredSymbol { name: n.to_owned(), kind: SymbolKind::Function, container: None, range: Range::default() }
StoredSymbol {
name: n.to_owned(),
kind: SymbolKind::Function,
container: None,
range: Range::default(),
bases: Vec::new(),
}
}
#[test]
+35
Переглянути файл
@@ -50,6 +50,17 @@ pub struct SymbolMatch {
pub indices: MatchIndices,
}
/// A class declaration of the index and the base names written in its source.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ClassDecl {
pub path: PathBuf,
pub name: String,
/// Selection range: the class name's identifier.
pub range: Range,
/// Bare base names, as written (`class X(pkg.mod.Base)` keeps `Base`).
pub bases: Vec<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SymbolFilter {
@@ -206,11 +217,34 @@ impl ProjectIndex {
kind: s.kind,
container: s.container.map(ToString::to_string),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
})
.collect(),
)
}
/// Every class declaration of the indexed project (content roots included) with the
/// base names written in its source, in path order. The UI builds an inheritance
/// graph from it, so it needs no language server's type hierarchy.
pub fn inheritance(&self) -> Vec<ClassDecl> {
let data = self.shared.data.read();
let mut out = Vec::new();
for entry in data.files.iter().flatten() {
for s in data.symbols_of(entry) {
if s.kind != SymbolKind::Class {
continue;
}
out.push(ClassDecl {
path: entry.path.clone(),
name: s.name.to_owned(),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
});
}
}
out
}
/// Bounded file inventory for background plugin indexers; honors the same
/// project/exclude scope as search and never walks the filesystem.
pub fn files_with_extensions(&self, extensions: &[String], limit: usize) -> Vec<PathBuf> {
@@ -517,6 +551,7 @@ pub mod bench_support {
kind: if k % 3 == 0 { SymbolKind::Class } else { SymbolKind::Method },
container: (k % 3 != 0).then(|| format!("{w}{s}")),
range: Range::default(),
bases: Vec::new(),
})
.collect();
let record = FileRecord { symbols, ..Default::default() };
+14 -2
Переглянути файл
@@ -11,8 +11,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
/// Bump when [`FileRecord`] or its encoding changes.
const SCHEMA: &str = "openidea-index-3";
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
const SCHEMA: &str = "openidea-index-4";
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
/// containing `gitdir: ...`).
@@ -113,6 +113,9 @@ struct FlatSymbol {
name_len: u32,
container_start: u32,
container_len: u32,
/// Base names joined with `'\0'` (`bases_len` 0 when the symbol has none).
bases_start: u32,
bases_len: u32,
kind: SymbolKind,
range: Range,
}
@@ -324,11 +327,14 @@ impl Snapshot {
let start = s.container_start as usize;
&self.text[start..start + s.container_len as usize]
});
let bases_start = s.bases_start as usize;
let bases = &self.text[bases_start..bases_start + s.bases_len as usize];
StoredSymbol {
name: name.to_owned(),
kind: s.kind,
container: container.map(str::to_owned),
range: s.range,
bases: bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
}
})
.collect();
@@ -498,11 +504,15 @@ impl Store {
}
None => (u32::MAX, 0),
};
let bases_start = fit(snap.text.len())?;
snap.text.push_str(s.bases);
snap.symbols.push(FlatSymbol {
name_start,
name_len: fit(s.name.len())?,
container_start,
container_len,
bases_start,
bases_len: fit(s.bases.len())?,
kind: s.kind,
range: s.range,
});
@@ -717,6 +727,7 @@ mod tests {
kind: SymbolKind::Class,
container: Some("Order".into()),
range: Range::default(),
bases: vec!["Base".into()],
}],
..Default::default()
};
@@ -740,6 +751,7 @@ mod tests {
assert_eq!(symbols.len(), 1);
assert_eq!(symbols[0].name, "OrderController");
assert_eq!(symbols[0].container.as_deref(), Some("Order"));
assert_eq!(symbols[0].bases, vec!["Base".to_string()], "bases survive the snapshot");
store.apply(&[], &[], false).unwrap();
assert!(store.load_snapshot().is_none(), "a file change invalidates the snapshot");
+23
Переглянути файл
@@ -567,6 +567,29 @@ fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn inheritance_reports_python_classes_and_their_bases() {
let f = Fixture::new(&[(
"app.py",
"class Base:\n pass\n\nclass Child(Base, other.Mixin):\n pass\n\nclass Plain:\n pass\n",
)]);
let idx = f.open();
let mut found: Vec<(String, u32, Vec<String>)> =
idx.inheritance().into_iter().map(|c| (c.name, c.range.start.line, c.bases)).collect();
found.sort();
assert_eq!(
found,
vec![
("Base".to_string(), 0, Vec::new()),
("Child".to_string(), 3, vec!["Base".to_string(), "Mixin".to_string()]),
("Plain".to_string(), 6, Vec::new()),
]
);
// Every class of the project is reported, even without a superclass: the UI needs
// them to resolve the base names of other files.
assert_eq!(idx.inheritance().len(), 3);
}
#[test]
fn content_roots_and_excludes_change_without_reopening() {
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
+7 -1
Переглянути файл
@@ -752,7 +752,13 @@ impl Shared {
.syntax
.tags(&lang, &text)
.into_iter()
.map(|t| StoredSymbol { name: t.name, kind: t.kind, container: t.container, range: t.range })
.map(|t| StoredSymbol {
name: t.name,
kind: t.kind,
container: t.container,
range: t.range,
bases: t.bases,
})
.collect();
}
Extracted::New(rec)
+1 -3
Переглянути файл
@@ -8,8 +8,6 @@ license.workspace = true
[dependencies]
futures.workspace = true
serde.workspace = true
serde_json.workspace = true
specta.workspace = true
thiserror.workspace = true
[dev-dependencies]
serde_json.workspace = true
+11
Переглянути файл
@@ -2,8 +2,10 @@
//! suspended. Implementations live elsewhere (jdtls bundle for Java, JDWP link for Kotlin).
mod names;
mod stream;
pub use names::{is_boxed, name_to_signature, signature_to_name, string_length};
pub use stream::{AbortState, CollectedTerminal, StreamTracer, TraceCollected, TraceId, TraceState};
use futures::future::BoxFuture;
use serde::{Deserialize, Serialize};
@@ -112,6 +114,15 @@ pub enum InspectError {
VmNotFound,
#[error("not supported by this debug adapter: {0}")]
Unsupported(String),
#[error("java-debug has no debug session for this JVM")]
NoSession,
/// The bundle's reason, e.g. which line the chain starts on.
#[error("the debuggee is not stopped where the stream chain starts: {0}")]
NotAtChainStart(String),
#[error("a stream trace is already running in this JVM")]
Busy,
#[error("there is no such stream trace in this JVM")]
NoTrace,
#[error("the request timed out")]
TimedOut,
#[error("the connection was closed")]
+84
Переглянути файл
@@ -0,0 +1,84 @@
//! Tracing a stream chain while the program itself runs it. One trace per VM; the trace's records
//! are read back once the debuggee is suspended again.
use crate::{InspectFuture, JvmValue, VmTarget};
use serde::{Deserialize, Serialize};
use specta::Type;
/// Assigned by the debuggee-side bundle; valid for one VM.
pub type TraceId = u64;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TraceState {
Running {
records: u64,
dropped: u64,
elapsed_ms: u64,
},
/// The terminal operation finished and the thread is suspended again, ready to `collect`.
Parked {
records: u64,
dropped: u64,
},
Failed {
detail: String,
},
/// Stopped or aborted before the terminal operation ran: taken down, the program untouched.
Cancelled {
detail: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum AbortState {
Interrupted,
Stopped,
/// Suspended threads that own a monitor the terminal may be waiting for: `(thread id, name)`.
Stuck {
holders: Vec<(i64, String)>,
},
/// The terminal had not started.
Cancelled,
/// The trace had already parked or failed.
Finished,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CollectedTerminal {
Value(JvmValue),
Void,
Threw(JvmValue),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraceCollected {
/// `(step, value)`: step counts the wrapped ops from 0 (the source).
pub records: Vec<(u16, JvmValue)>,
/// Records past the arm-time budget; counted, not kept.
pub dropped: u64,
pub terminal: CollectedTerminal,
pub skipped_breakpoints: u32,
/// A parallel chain was forced to run sequentially so that records keep their order.
pub sequentialized: bool,
}
pub trait StreamTracer: Send + Sync {
/// `plan` is the JSON of `ide_streams::RealRunPlan`; `budget` caps the records kept.
fn arm<'a>(
&'a self,
target: &'a VmTarget,
thread_id: i64,
plan: &'a serde_json::Value,
budget: u32,
) -> InspectFuture<'a, TraceId>;
/// Blocks up to `ms` milliseconds for the trace to leave `Running`.
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState>;
/// Stops keeping records while the terminal keeps running; returns the records kept so far.
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64>;
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState>;
/// `target.generation` must be a stop after the trace parked. `records`: how many it parked
/// with; reading each takes a round trip to the JVM, so the time allowed grows with them.
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected>;
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()>;
}
+24
Переглянути файл
@@ -73,6 +73,21 @@ pub struct LanguageConfig {
/// Content of a new scratch file; `$END$` marks where the caret goes.
#[serde(default)]
pub scratch_template: Option<String>,
/// Syntax nodes of the editor's grammar whose `<` `>` rainbow brackets colour.
#[serde(default)]
pub rainbow_brackets: RainbowBracketNodes,
}
/// `[rainbow-brackets]` of a language definition: node names of its editor (Lezer)
/// grammar, so angle brackets are coloured only where the syntax tree says they
/// delimit something, never in comparisons or shifts.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default)]
pub struct RainbowBracketNodes {
/// Nodes spanning `<` … `>` whose delimiters pair up: type argument and parameter lists.
pub angle: Vec<String>,
/// Markup tags (`<a>`, `</a>`, `<a/>`); an element's start and end tags pair up.
pub tags: Vec<String>,
}
/// An external formatting tool and its language-specific parser.
@@ -302,6 +317,10 @@ pub struct LanguageInfo {
#[serde(default)]
#[specta(optional)]
pub scratch_template: Option<String>,
/// Syntax nodes whose `<` `>` rainbow brackets colour (Color Scheme › Rainbow brackets).
#[serde(default)]
#[specta(optional)]
pub rainbow_brackets: RainbowBracketNodes,
}
impl From<&LanguageConfig> for LanguageInfo {
@@ -319,6 +338,7 @@ impl From<&LanguageConfig> for LanguageInfo {
filenames: c.filenames.clone(),
first_line: c.first_line.clone(),
scratch_template: c.scratch_template.clone(),
rainbow_brackets: c.rainbow_brackets.clone(),
}
}
}
@@ -347,6 +367,10 @@ pub struct SymbolTag {
/// Enclosing symbol, e.g. class name for a method.
pub container: Option<String>,
pub range: Range,
/// Bare base names written in a class definition (`class X(A, B)`); empty for
/// every other symbol, and for languages whose classes carry none.
#[serde(default)]
pub bases: Vec<String>,
}
/// One inline TS/JS `<script>` block of a Vue SFC / HTML document.
+14
Переглянути файл
@@ -667,6 +667,20 @@ mod tests {
assert_eq!(rust.language_servers[0].name, "rust-analyzer");
}
#[test]
fn rainbow_bracket_nodes_reach_the_ui() {
let reg = reg();
let tsx = reg.get(&LanguageId::new("typescriptreact")).unwrap();
assert_eq!(tsx.rainbow_brackets.angle, ["TypeArgList", "TypeParamList"]);
assert!(tsx.rainbow_brackets.tags.iter().any(|t| t == "JSXOpenTag"));
let info = crate::LanguageInfo::from(&reg.get(&LanguageId::new("html")).unwrap());
assert_eq!(info.rainbow_brackets.tags, ["OpenTag", "CloseTag", "SelfClosingTag"]);
let json = serde_json::to_value(&info).unwrap();
assert_eq!(json["rainbowBrackets"]["tags"][0], "OpenTag");
// Definitions without the table, as most are, get none.
assert_eq!(reg.get(&LanguageId::new("python")).unwrap().rainbow_brackets, Default::default());
}
#[test]
fn alternative_servers_are_fallbacks() {
let reg = reg();
+18 -3
Переглянути файл
@@ -67,9 +67,10 @@ fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
}
}
/// The bare base names a `class_definition` node writes (keyword arguments left out).
pub(super) fn class_base_names(node: Node, text: &str) -> Vec<String> {
node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
/// Bare base names of a `class_definition` node (`[]` without a superclass list).
/// Shared with the outline query, whose tags carry the bases of a class definition.
pub(super) fn class_base_names(class: Node, text: &str) -> Vec<String> {
class.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
}
fn base_names(args: Node, text: &str) -> Vec<String> {
@@ -121,6 +122,20 @@ mod tests {
assert_eq!(shape("class A: pass"), vec![("A".to_owned(), 0, 6, vec![])]);
}
/// The project index stores bases on the symbol tags, so the outline query must
/// carry them too (one parse for both, not a second pass over every file).
#[test]
fn tags_carry_class_bases() {
static S: std::sync::OnceLock<Syntax> = std::sync::OnceLock::new();
let s = S.get_or_init(Syntax::new);
let tags = s.tags(&LanguageId::new("python"), "class A: pass\nclass B(A, pkg.C):\n def m(self): pass\n");
let bases_of = |name: &str| tags.iter().find(|t| t.name == name).map(|t| t.bases.clone()).unwrap_or_default();
assert!(bases_of("A").is_empty());
assert_eq!(bases_of("B"), vec!["A".to_owned(), "C".to_owned()]);
// Only classes carry bases; the method's tag stays empty.
assert!(bases_of("m").is_empty());
}
#[test]
fn multiple_bases_skips_metaclass() {
assert_eq!(
+10
Переглянути файл
@@ -143,6 +143,8 @@ struct Raw {
visibility: Option<Visibility>,
/// Rust `impl Trait for Type`: members take the trait's visibility.
trait_impl: bool,
/// Base names of a class definition (empty where the grammar has none).
bases: Vec<String>,
}
struct Built {
@@ -221,6 +223,13 @@ fn collect(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Vec<Built>
detail: detail.map(|d| clean(node_text(&d, text), 80)).filter(|d| !d.is_empty()),
visibility: explicit_visibility(&node, text),
trait_impl,
// The index needs every class's bases; Python is the grammar that has them.
bases: match kind {
ItemKind::Symbol(SymbolKind::Class) if g.spec.name == "python" => {
super::inheritance::class_base_names(node, text)
}
_ => Vec::new(),
},
};
match by_node.get(&raw.node_id) {
Some(existing) if existing.pattern <= raw.pattern => {}
@@ -369,6 +378,7 @@ pub(crate) fn tags(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Ve
kind: b.kind,
container: own_container.map(str::to_owned),
range: b.raw.sel,
bases: b.raw.bases.clone(),
});
}
let next = if b.raw.tag || matches!(b.raw.kind, ItemKind::Impl | ItemKind::Extension) {
+1 -1
Переглянути файл
@@ -129,7 +129,7 @@ pub(crate) fn definitions(g: &Grammar, css: Option<&Grammar>, tree: &Tree, text:
};
if let Some((name, kind)) = def {
let range = idx.range(base + n.start_byte(), base + n.end_byte());
out.push(SymbolTag { name, kind, container: None, range });
out.push(SymbolTag { name, kind, container: None, range, bases: Vec::new() });
}
true
});
+1
Переглянути файл
@@ -26,6 +26,7 @@ pub(crate) mod jvm_inspect;
mod move_refactoring;
pub(crate) mod reserved_names;
mod signature;
pub(crate) mod stream_trace;
pub use formatter::configure_formatter;
/// First start imports the Maven / Gradle model, which can take minutes.
const READY_TIMEOUT: Duration = Duration::from_secs(240);
+8 -3
Переглянути файл
@@ -63,7 +63,7 @@ impl JdtJvmInspector {
}
/// `VmTarget` is not `Serialize`: the field names here are the bundle's.
fn target_json(target: &VmTarget) -> Value {
pub(super) fn target_json(target: &VmTarget) -> Value {
json!({
"pid": target.pid,
"host": target.attach_host,
@@ -72,7 +72,7 @@ fn target_json(target: &VmTarget) -> Value {
})
}
fn command_error(e: IdeError) -> InspectError {
pub(super) fn command_error(e: IdeError) -> InspectError {
if missing_bundle(&e) {
InspectError::Unsupported("the JVM inspector bundle is not loaded".to_owned())
} else {
@@ -81,7 +81,7 @@ fn command_error(e: IdeError) -> InspectError {
}
/// `{"ok": payload}` or `{"error": code, "detail": text}`.
fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
pub(super) fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
if let Some(code) = reply.get("error").and_then(Value::as_str) {
let detail = reply.get("detail").and_then(Value::as_str);
return Err(match code {
@@ -94,6 +94,11 @@ fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
"classNotLoaded" => InspectError::ClassNotLoaded,
"notSuspended" => InspectError::NotSuspended,
"timedOut" => InspectError::TimedOut,
"noSession" => InspectError::NoSession,
"notAtChainStart" => InspectError::NotAtChainStart(detail.unwrap_or_default().to_owned()),
"busy" => InspectError::Busy,
"noTrace" => InspectError::NoTrace,
"failed" | "badArgument" => InspectError::Failed(detail.unwrap_or(code).to_owned()),
other => InspectError::Failed(match detail {
Some(detail) => format!("{other}: {detail}"),
None => other.to_owned(),
+238
Переглянути файл
@@ -0,0 +1,238 @@
//! [`StreamTracer`] over the `openidea.jvm.stream.*` commands of the JVM inspector bundle that runs
//! inside jdtls (`java/jvm-inspect`).
use super::jvm_inspect::{command_error, decode, target_json};
use crate::LspManager;
use ide_jvm_inspect::{
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
TraceState, VmTarget,
};
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use tokio::time::timeout;
/// `wait` is held by the bundle for the `ms` it is given; the command times out this long after.
const WAIT_SLACK: Duration = Duration::from_secs(10);
const ABORT_TIMEOUT: Duration = Duration::from_secs(15);
const COMMAND_TIMEOUT: Duration = Duration::from_secs(15);
/// Each record is previewed with at least one JDWP round trip (about 0.1 ms locally, far more
/// over a remote attach).
fn collect_timeout(records: u64) -> Duration {
Duration::from_secs(60)
.saturating_add(Duration::from_millis(5).saturating_mul(records.try_into().unwrap_or(u32::MAX)))
}
pub struct JdtStreamTracer {
lsp: Arc<LspManager>,
/// A path inside the module whose jdtls runs the debug session.
server: PathBuf,
}
impl JdtStreamTracer {
/// Deliberately without `JdtJvmInspector`'s turn: a `wait` that holds a JDT LS thread for
/// seconds must not keep the memory view from reading while the trace runs.
pub fn new(lsp: Arc<LspManager>, server: PathBuf) -> Self {
Self { lsp, server }
}
async fn call<T: DeserializeOwned>(
&self,
op: &str,
target: &VmTarget,
args: Value,
limit: Duration,
) -> Result<T, InspectError> {
let command = format!("openidea.jvm.stream.{op}");
let arguments = vec![target_json(target), args];
let reply = timeout(limit, self.lsp.jdtls_command(&self.server, &command, arguments))
.await
.map_err(|_| InspectError::TimedOut)?
.map_err(command_error)?;
decode(reply)
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Armed {
trace_id: TraceId,
}
#[derive(Deserialize)]
#[serde(tag = "state", rename_all = "camelCase", rename_all_fields = "camelCase")]
enum WireState {
Running {
records: u64,
dropped: u64,
elapsed_ms: u64,
},
Parked {
records: u64,
dropped: u64,
},
Failed {
#[serde(default)]
detail: String,
},
Cancelled {
#[serde(default)]
detail: String,
},
}
impl From<WireState> for TraceState {
fn from(state: WireState) -> Self {
match state {
WireState::Running { records, dropped, elapsed_ms } => Self::Running { records, dropped, elapsed_ms },
WireState::Parked { records, dropped } => Self::Parked { records, dropped },
WireState::Failed { detail } => Self::Failed { detail },
WireState::Cancelled { detail } => Self::Cancelled { detail },
}
}
}
#[derive(Deserialize)]
struct Stopped {
records: u64,
}
#[derive(Deserialize)]
#[serde(tag = "state", rename_all = "camelCase")]
enum WireAbort {
Interrupted,
Stopped,
Stuck {
#[serde(default)]
holders: Vec<Holder>,
},
Cancelled,
Finished,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Holder {
thread_id: i64,
name: String,
}
impl From<WireAbort> for AbortState {
fn from(state: WireAbort) -> Self {
match state {
WireAbort::Interrupted => Self::Interrupted,
WireAbort::Stopped => Self::Stopped,
WireAbort::Stuck { holders } => {
Self::Stuck { holders: holders.into_iter().map(|h| (h.thread_id, h.name)).collect() }
}
WireAbort::Cancelled => Self::Cancelled,
WireAbort::Finished => Self::Finished,
}
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct WireCollected {
records: Vec<WireRecord>,
dropped: u64,
terminal: WireTerminal,
skipped_breakpoints: u32,
sequentialized: bool,
}
#[derive(Deserialize)]
struct WireRecord {
step: u16,
value: JvmValue,
}
#[derive(Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
enum WireTerminal {
Value { value: JvmValue },
Void,
Threw { exception: JvmValue },
}
impl From<WireCollected> for TraceCollected {
fn from(wire: WireCollected) -> Self {
Self {
records: wire.records.into_iter().map(|r| (r.step, r.value)).collect(),
dropped: wire.dropped,
terminal: match wire.terminal {
WireTerminal::Value { value } => CollectedTerminal::Value(value),
WireTerminal::Void => CollectedTerminal::Void,
WireTerminal::Threw { exception } => CollectedTerminal::Threw(exception),
},
skipped_breakpoints: wire.skipped_breakpoints,
sequentialized: wire.sequentialized,
}
}
}
impl StreamTracer for JdtStreamTracer {
fn arm<'a>(
&'a self,
target: &'a VmTarget,
thread_id: i64,
plan: &'a Value,
budget: u32,
) -> InspectFuture<'a, TraceId> {
Box::pin(async move {
let args = json!({"threadId": thread_id, "plan": plan, "budget": budget});
Ok(self.call::<Armed>("arm", target, args, COMMAND_TIMEOUT).await?.trace_id)
})
}
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState> {
Box::pin(async move {
let limit = Duration::from_millis(u64::from(ms)) + WAIT_SLACK;
let state: WireState = self.call("wait", target, json!({"traceId": trace, "ms": ms}), limit).await?;
Ok(state.into())
})
}
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64> {
Box::pin(async move {
Ok(self.call::<Stopped>("stop", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await?.records)
})
}
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState> {
Box::pin(async move {
let state: WireAbort = self.call("abort", target, json!({"traceId": trace}), ABORT_TIMEOUT).await?;
Ok(state.into())
})
}
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
Box::pin(async move {
let limit = collect_timeout(records);
let collected: WireCollected = self.call("collect", target, json!({"traceId": trace}), limit).await?;
Ok(collected.into())
})
}
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()> {
Box::pin(async move {
self.call::<Value>("release", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await.map(drop)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collect_timeout_grows_with_the_records() {
assert_eq!(collect_timeout(0), Duration::from_secs(60));
assert_eq!(collect_timeout(50_000), Duration::from_secs(60 + 250));
assert!(collect_timeout(u64::MAX) >= collect_timeout(50_000));
}
}
+1
Переглянути файл
@@ -44,6 +44,7 @@ mod vue_refs;
pub use injections::{InjectedRange, InjectionProvider, MAX_INJECTED_DOCUMENT_BYTES};
pub use inspect::{CheckedServer, DocumentCheck, FileInspection, InspectHost, InspectOptions};
pub use jdtls::jvm_inspect::JdtJvmInspector;
pub use jdtls::stream_trace::JdtStreamTracer;
pub use kotlin_lsp::{KotlinDebugServer, KotlinDebugUnavailable};
pub use launch::{LaunchError, Launcher, ProcessLauncher};
pub use notebook::{NotebookCell, NotebookCellDoc, cell_uri};
+217
Переглянути файл
@@ -324,6 +324,7 @@ fn harness_languages(languages: &[MockLanguage<'_>], adjust: impl Fn(&mut Langua
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: servers
.iter()
@@ -3170,6 +3171,222 @@ async fn jvm_inspect_sends_one_command_at_a_time() {
assert_eq!(most.load(Ordering::SeqCst), 1);
}
async fn stream_harness() -> (Harness, Arc<MockState>, ide_lsp::JdtStreamTracer) {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
let (_, path) = h.open("Sample.java", "class Sample {}");
h.wait_status("jdtls", ServerStatus::Ready).await;
let tracer = ide_lsp::JdtStreamTracer::new(h.mgr.clone(), path);
let state = h.launcher.state("jdtls");
(h, state, tracer)
}
fn stream_launch_target() -> ide_jvm_inspect::VmTarget {
ide_jvm_inspect::VmTarget { pid: Some(42), attach_host: None, attach_port: None, generation: 3 }
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_commands_send_target_then_named_fields() {
use ide_jvm_inspect::StreamTracer;
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let target_json = json!({"pid": 42, "host": null, "port": null, "generation": 3});
let plan = json!({"root": {"line": 14}});
s.respond("workspace/executeCommand", json!({"ok": {"traceId": 3}}));
assert_eq!(tracer.arm(&target, 7, &plan, 500).await.unwrap(), 3);
s.respond(
"workspace/executeCommand",
json!({"ok": {"state": "running", "records": 1, "dropped": 0, "elapsedMs": 2}}),
);
tracer.wait(&target, 3, 250).await.unwrap();
s.respond("workspace/executeCommand", json!({"ok": {"records": 9}}));
assert_eq!(tracer.stop(&target, 3).await.unwrap(), 9);
s.respond("workspace/executeCommand", json!({"ok": {"state": "stopped"}}));
tracer.abort(&target, 3).await.unwrap();
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"}, "skippedBreakpoints": 0,
"sequentialized": false}}),
);
tracer.collect(&target, 3, 2).await.unwrap();
s.respond("workspace/executeCommand", json!({"ok": {}}));
tracer.release(&target, 3).await.unwrap();
let asked = s.requested("workspace/executeCommand");
let seen: Vec<_> = asked.iter().map(|p| (p["command"].clone(), p["arguments"].clone())).collect();
assert_eq!(
seen,
vec![
(json!("openidea.jvm.stream.arm"), json!([target_json, {"threadId": 7, "plan": plan, "budget": 500}])),
(json!("openidea.jvm.stream.wait"), json!([target_json, {"traceId": 3, "ms": 250}])),
(json!("openidea.jvm.stream.stop"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.abort"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.collect"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.release"), json!([target_json, {"traceId": 3}])),
]
);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_wait_decodes_states() {
use ide_jvm_inspect::{StreamTracer, TraceState};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(
json!({"state": "running", "records": 10, "dropped": 0, "elapsedMs": 5}),
TraceState::Running { records: 10, dropped: 0, elapsed_ms: 5 },
),
(
json!({"state": "parked", "records": 50000, "dropped": 950000, "elapsedMs": 96}),
TraceState::Parked { records: 50000, dropped: 950000 },
),
(
json!({"state": "failed", "records": 4, "dropped": 0, "elapsedMs": 12, "detail": "missed map"}),
TraceState::Failed { detail: "missed map".into() },
),
(
json!({"state": "cancelled", "records": 0, "dropped": 0, "elapsedMs": 12,
"detail": "cancelled before the terminal ran"}),
TraceState::Cancelled { detail: "cancelled before the terminal ran".into() },
),
];
for (ok, expected) in cases {
s.respond("workspace/executeCommand", json!({"ok": ok}));
assert_eq!(tracer.wait(&target, 1, 10).await.unwrap(), expected, "{ok}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_abort_decodes_every_state() {
use ide_jvm_inspect::{AbortState, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(json!({"state": "interrupted"}), AbortState::Interrupted),
(json!({"state": "stopped"}), AbortState::Stopped),
(
json!({"state": "stuck", "holders": [{"threadId": 42, "name": "worker-1"}]}),
AbortState::Stuck { holders: vec![(42, "worker-1".into())] },
),
(json!({"state": "cancelled"}), AbortState::Cancelled),
(json!({"state": "finished"}), AbortState::Finished),
];
for (ok, expected) in cases {
s.respond("workspace/executeCommand", json!({"ok": ok}));
assert_eq!(tracer.abort(&target, 1).await.unwrap(), expected, "{ok}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_errors_map() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(
json!({"error": "notAtChainStart", "detail": "line 14 is not where the statement starts"}),
InspectError::NotAtChainStart("line 14 is not where the statement starts".into()),
),
(json!({"error": "busy", "detail": "trace 2 is running"}), InspectError::Busy),
(json!({"error": "noTrace", "detail": "no trace 9 on this VM"}), InspectError::NoTrace),
(json!({"error": "noSession", "detail": "x"}), InspectError::NoSession),
(json!({"error": "stale", "detail": "no thread 77"}), InspectError::Stale),
(json!({"error": "notSuspended", "detail": "thread 1 is running"}), InspectError::NotSuspended),
(json!({"error": "unsupported", "detail": "xs is a List"}), InspectError::Unsupported("xs is a List".into())),
(
json!({"error": "badArgument", "detail": "budget must be 1 or more"}),
InspectError::Failed("budget must be 1 or more".into()),
),
(json!({"error": "failed", "detail": "missed filter"}), InspectError::Failed("missed filter".into())),
(json!({"error": "surprise", "detail": "d"}), InspectError::Failed("surprise: d".into())),
];
for (reply, expected) in cases {
s.respond("workspace/executeCommand", reply.clone());
assert_eq!(tracer.arm(&target, 1, &json!({}), 10).await.unwrap_err(), expected, "{reply}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_missing_bundle_is_unsupported() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
s.errors.lock().insert(
"workspace/executeCommand".into(),
(-32603, "No delegateCommandHandler for openidea.jvm.stream.wait".into()),
);
assert_eq!(
tracer.wait(&stream_launch_target(), 1, 10).await.unwrap_err(),
InspectError::Unsupported("the JVM inspector bundle is not loaded".into())
);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_collect_decodes() {
use ide_jvm_inspect::{CollectedTerminal, JvmValue, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
s.respond(
"workspace/executeCommand",
json!({"ok": {
"records": [
{"step": 0, "value": {"kind": "boxed", "id": 1, "typeName": "java.lang.Integer", "text": "5"}},
{"step": 1, "value": {"kind": "string", "id": 2, "text": "5", "length": 1}},
],
"dropped": 4,
"terminal": {"kind": "threw",
"exception": {"kind": "object", "id": 9, "typeName": "java.lang.ArithmeticException"}},
"skippedBreakpoints": 1,
"sequentialized": true,
}}),
);
let collected = tracer.collect(&target, 3, 2).await.unwrap();
assert_eq!(
collected.records,
vec![
(0, JvmValue::Boxed { id: 1, type_name: "java.lang.Integer".into(), text: "5".into() }),
(1, JvmValue::Str { id: 2, text: Some("5".into()), length: 1 }),
]
);
assert_eq!(collected.dropped, 4);
assert_eq!(
collected.terminal,
CollectedTerminal::Threw(JvmValue::Object { id: 9, type_name: "java.lang.ArithmeticException".into() })
);
assert_eq!(collected.skipped_breakpoints, 1);
assert!(collected.sequentialized);
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0,
"terminal": {"kind": "value", "value": {"kind": "object", "id": 19, "typeName": "java.util.ArrayList"}},
"skippedBreakpoints": 0, "sequentialized": false}}),
);
assert_eq!(
tracer.collect(&target, 3, 2).await.unwrap().terminal,
CollectedTerminal::Value(JvmValue::Object { id: 19, type_name: "java.util.ArrayList".into() })
);
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"},
"skippedBreakpoints": 0, "sequentialized": false}}),
);
assert_eq!(tracer.collect(&target, 3, 2).await.unwrap().terminal, CollectedTerminal::Void);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_collect_fails_cleanly_on_a_step_beyond_u16() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [{"step": 70000, "value": {"kind": "null"}}], "dropped": 0,
"terminal": {"kind": "void"}, "skippedBreakpoints": 0, "sequentialized": false}}),
);
let error = tracer.collect(&stream_launch_target(), 3, 2).await.unwrap_err();
assert!(matches!(error, InspectError::Failed(ref m) if m.contains("malformed")), "{error:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn debug_server_port_maps_to_module() {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
+1
Переглянути файл
@@ -58,6 +58,7 @@ fn lang(id: &str, ext: &str, server: LanguageServerConfig) -> LanguageConfig {
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![server],
debugger: None,
+23
Переглянути файл
@@ -38,6 +38,29 @@ pub struct ContentDiff {
pub title: Option<String>,
}
/// A diff opened by a plugin (API 1.10): `None` is a side where the file doesn't exist.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FileDiff {
pub left: Option<String>,
pub right: Option<String>,
pub left_label: Option<String>,
pub right_label: Option<String>,
pub title: Option<String>,
}
impl From<ContentDiff> for FileDiff {
fn from(v: ContentDiff) -> Self {
Self {
left: Some(v.left),
right: Some(v.right),
left_label: v.left_label,
right_label: v.right_label,
title: v.title,
}
}
}
/// ContentTabReply data exchanged with the IDE.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+10 -3
Переглянути файл
@@ -56,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.9";
pub const API_VERSION: &str = "1.10";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
pub(crate) const MAX_TITLE: usize = 256;
@@ -117,6 +117,13 @@ pub trait HostApi: Send + Sync {
let _ = (root, method, params, notify, cancel, timeout);
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// The flat dependency graph of the Maven / Gradle builds of the project at `root`
/// (of the module `module` only, when given), as the IDE last resolved it; never runs
/// a build tool.
fn build_dependencies(&self, root: &Path, module: Option<&str>) -> Result<Vec<crate::DependencyNode>, HostError> {
let _ = (root, module);
Err(HostError::Failed("build data is unavailable on this host".into()))
}
/// Stdio argv only; no URL or bearer token.
fn mcp_stdio_command(&self, client: &str) -> Option<Vec<String>> {
let _ = client;
@@ -188,8 +195,8 @@ pub trait HostApi: Send + Sync {
let _ = (client, tab, cancel, timeout);
Err(HostError::Failed("content tabs unavailable".into()))
}
/// Opens a diff of two texts in the invoking window.
fn open_diff(&self, client: &str, diff: crate::ContentDiff, file_name: Option<String>) -> Result<(), HostError> {
/// Opens a diff of two texts in the invoking window; a `None` side doesn't exist.
fn open_diff(&self, client: &str, diff: crate::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
let _ = (client, diff, file_name);
Err(HostError::Failed("diffs unavailable".into()))
}
+22
Переглянути файл
@@ -959,6 +959,28 @@ pub struct BlameLine {
pub summary: String,
}
/// How an occurrence in a build's dependency graph was resolved (API 1.10).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DependencyStatus {
Resolved,
OmittedForConflict,
OmittedForDuplicate,
VersionManaged,
}
/// One occurrence in the flat dependency graph of `build.dependencies` (API 1.10);
/// `parent` indexes the list.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DependencyNode {
pub group: String,
pub artifact: String,
pub version: String,
pub scope: String,
pub status: DependencyStatus,
pub requested_version: Option<String>,
pub parent: Option<u32>,
}
/// Non-secret settings of a plugin-owned project database source (API 1.4).
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
+56 -2
Переглянути файл
@@ -48,6 +48,7 @@ pub(crate) mod syntax_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -87,6 +88,7 @@ pub(crate) mod providers_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -126,6 +128,7 @@ pub(crate) mod views_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -150,8 +153,8 @@ pub(crate) mod views_bindings {
}
use bindings::openidea::plugin::{
commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets, settings,
storage, tasks, types as wit, ui, vcs, views, workspace,
build, commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets,
settings, storage, tasks, types as wit, ui, vcs, views, workspace,
};
/// A project handle: its root.
@@ -1192,6 +1195,44 @@ impl vcs::Host for StoreData {
}
}
impl build::Host for StoreData {
fn dependencies(
&mut self,
project: Resource<ProjectRes>,
module: Option<String>,
) -> Fallible<Vec<build::DependencyNode>> {
if let Err(e) = self.require(Capability::BuildRead) {
return Ok(Err(e));
}
let root = self.table.get(&project)?.root.clone();
Ok(self
.host
.build_dependencies(&root, module.as_deref())
.map(|nodes| {
nodes
.into_iter()
.map(|n| build::DependencyNode {
group: n.group,
artifact: n.artifact,
version: n.version,
scope: n.scope,
status: match n.status {
crate::DependencyStatus::Resolved => build::DependencyStatus::Resolved,
crate::DependencyStatus::OmittedForConflict => build::DependencyStatus::OmittedForConflict,
crate::DependencyStatus::OmittedForDuplicate => {
build::DependencyStatus::OmittedForDuplicate
}
crate::DependencyStatus::VersionManaged => build::DependencyStatus::VersionManaged,
},
requested_version: n.requested_version,
parent: n.parent,
})
.collect()
})
.map_err(to_wit))
}
}
impl commit::Host for StoreData {
fn pending_commit(&mut self) -> Fallible<Option<commit::CommitDraft>> {
if let Err(e) = self.require(Capability::VcsRead) {
@@ -1782,6 +1823,13 @@ impl views::Host for StoreData {
.map_err(to_wit))
}
fn open_diff(&mut self, diff: views::ContentDiff, file_name: Option<String>) -> Fallible<()> {
if let Err(e) = self.require_window() {
return Ok(Err(e));
}
let diff = crate::FileDiff::from(crate::ContentDiff::from(diff));
Ok(self.host.open_diff(self.invocation.client.as_deref().unwrap(), diff, file_name).map_err(to_wit))
}
fn open_file_diff(&mut self, diff: views::FileDiff, file_name: Option<String>) -> Fallible<()> {
if let Err(e) = self.require_window() {
return Ok(Err(e));
}
@@ -2146,6 +2194,12 @@ impl From<bindings::openidea::plugin::views::ContentDiff> for crate::ContentDiff
}
}
impl From<bindings::openidea::plugin::views::FileDiff> for crate::FileDiff {
fn from(v: bindings::openidea::plugin::views::FileDiff) -> Self {
Self { left: v.left, right: v.right, left_label: v.left_label, right_label: v.right_label, title: v.title }
}
}
impl From<bindings::openidea::plugin::views::ContentTabReply> for crate::ContentTabReply {
fn from(v: bindings::openidea::plugin::views::ContentTabReply) -> Self {
Self {
+5 -5
Переглянути файл
@@ -91,15 +91,15 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.9.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.0.0-rc.1"] {
let host = v("1.10.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.0.0-rc.1"] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.10.0"), &host).unwrap_err();
assert!(newer.contains("1.10") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.11.0"), &host).unwrap_err();
assert!(newer.contains("1.11") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.9 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.10 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
75123cf60f87ec9bdd36e0b7f75efb69d000136d74c3e9da893ecd1534bdf534
f6069ad2d31b629e4c99fbb800b3bf389ffb87ca7f24fc9cf7803fef68997ef5
+336
Переглянути файл
@@ -0,0 +1,336 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "bitflags"
version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "foldhash"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "id-arena"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
"serde",
"serde_core",
]
[[package]]
name = "itoa"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
[[package]]
name = "leb128fmt"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
[[package]]
name = "log"
version = "0.4.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
[[package]]
name = "macro-string"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "openidea-plugin"
version = "0.1.0"
dependencies = [
"serde",
"serde_json",
"wit-bindgen",
]
[[package]]
name = "openidea-test-build-graph"
version = "0.1.0"
dependencies = [
"openidea-plugin",
]
[[package]]
name = "prettyplease"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
dependencies = [
"proc-macro2",
"syn",
]
[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
[[package]]
name = "semver"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
[[package]]
name = "serde"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.154"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "syn"
version = "3.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
[[package]]
name = "wasm-encoder"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
dependencies = [
"leb128fmt",
"wasmparser",
]
[[package]]
name = "wasm-metadata"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
dependencies = [
"anyhow",
"indexmap",
"wasm-encoder",
"wasmparser",
]
[[package]]
name = "wasmparser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
dependencies = [
"bitflags",
"hashbrown",
"indexmap",
"semver",
]
[[package]]
name = "wit-bindgen"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
dependencies = [
"bitflags",
"wit-bindgen-rust-macro",
]
[[package]]
name = "wit-bindgen-core"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
dependencies = [
"anyhow",
"heck",
"wit-parser",
]
[[package]]
name = "wit-bindgen-rust"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
dependencies = [
"anyhow",
"heck",
"indexmap",
"prettyplease",
"syn",
"wasm-metadata",
"wit-bindgen-core",
"wit-component",
]
[[package]]
name = "wit-bindgen-rust-macro"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
dependencies = [
"anyhow",
"macro-string",
"prettyplease",
"proc-macro2",
"quote",
"syn",
"wit-bindgen-core",
"wit-bindgen-rust",
]
[[package]]
name = "wit-component"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
dependencies = [
"anyhow",
"bitflags",
"indexmap",
"log",
"serde",
"serde_derive",
"serde_json",
"wasm-encoder",
"wasm-metadata",
"wasmparser",
"wit-parser",
]
[[package]]
name = "wit-parser"
version = "0.262.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
dependencies = [
"anyhow",
"hashbrown",
"id-arena",
"indexmap",
"log",
"semver",
"serde",
"serde_derive",
"serde_json",
"unicode-ident",
"wasmparser",
]
[[package]]
name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+20
Переглянути файл
@@ -0,0 +1,20 @@
[package]
name = "openidea-test-build-graph"
version = "0.1.0"
edition = "2024"
publish = false
[workspace]
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
openidea-plugin = { path = "../../../../../sdk/rust/openidea-plugin" }
[profile.release]
opt-level = "s"
lto = true
strip = true
codegen-units = 1
panic = "abort"
Бінарний файл не відображається.
+1
Переглянути файл
@@ -0,0 +1 @@
178a2dd60891bfa56a02be322b47dfdbbf22f6e0a50ac56a4b7e4ae1520a821a
+12
Переглянути файл
@@ -0,0 +1,12 @@
id = "test.build-graph"
name = "Build dependency graph fixture"
version = "0.1.0"
engines.openidea = "^1.10"
wasm = "dist/plugin.wasm"
[capabilities]
optional = ["build.read"]
[[contributes.commands]]
id = "dependencies"
title = "List the dependency graph of a module, or of every module"
+32
Переглянути файл
@@ -0,0 +1,32 @@
use openidea_plugin::{DependencyStatus, Error, Invocation, Plugin, register_plugin};
#[derive(Default)]
struct BuildGraph;
impl Plugin for BuildGraph {
fn run_command(&mut self, id: &str, inv: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
if id != "dependencies" {
return Err(Error::NotFound(id.into()));
}
let project = inv.project().ok_or("no project")?;
// One line per node: `parent group:artifact:version scope status requested`.
let lines: Vec<String> = project
.build_dependencies(arg.filter(|m| !m.is_empty()))?
.into_iter()
.map(|n| {
let status = match n.status {
DependencyStatus::Resolved => "resolved",
DependencyStatus::OmittedForConflict => "conflict",
DependencyStatus::OmittedForDuplicate => "duplicate",
DependencyStatus::VersionManaged => "managed",
};
let parent = n.parent.map_or("-".into(), |p| p.to_string());
let requested = n.requested_version.unwrap_or_else(|| "-".into());
format!("{parent} {}:{}:{} {} {status} {requested}", n.group, n.artifact, n.version, n.scope)
})
.collect();
Ok(Some(lines.join("\n")))
}
}
register_plugin!(BuildGraph);
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
60d66ec578e3adc7adaebbcd01aa92a74a8a7e4cfd4d1aa778f9b033c75234a6
c39252e48882cb605286f95d1115a3293c191538d7762d1d3ce3afb1bfad814b
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
df55973ed77e734e48fe1d2b7bb5d1e4eb68153b17452e4385599145427292b6
0809519ebb56f31b1f00d1e256a6d1af4e1c357990226ef949ac61f1e61989d6
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
94f1c4a8192e15961bd136cf9dc3416fca7b295bce0d563608a3ee9fdf81c28e
9a9ace3a2818a4cee15f6a20cb0bab96d908090cdcf98a708b4e3558006e224a
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
db140480eaf4352fa8db8d87aab95cb07944e19c28d2cc08e299b37c5deb4230
910123140c7d4b354c820088df9adde69916051ebc6cc732bc7847f6d7eb5f52
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
5fd76f6168d3a7b3259281171f375cf01da6ceabdf4ffd382c5fe7034b2e94f2
067039e5e40e0c0586277641797557c3f454b44909cd2b008ea46b3b81963686
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
5d9049fa006194e92e06de47ab933d249118706a8ba92100493318a1582f2b65
93bda7983e8597f6b90b9a2877de8e4217451a2cdf47436c525490554f2168d2
Бінарний файл не відображається.
Loaded 100 of 540 files, more files were not shown because too many files have changed in this diff. Show more