дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-19 08:05:40 +02:00
Порівняти коміти
1
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
4867c99734 |
No files matched your search
@@ -1,41 +0,0 @@
|
||||
name: Cancel runs of closed PRs
|
||||
on:
|
||||
# pull_request_target so it also runs for PRs from forks. It never checks out or
|
||||
# runs PR code: it only lists and cancels workflow runs of the closed PR's branch.
|
||||
pull_request_target:
|
||||
types: [closed]
|
||||
|
||||
permissions:
|
||||
actions: write
|
||||
|
||||
jobs:
|
||||
cancel:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/github-script@v8
|
||||
with:
|
||||
script: |
|
||||
// A merged or closed PR's remaining CI only holds runners other PRs wait for.
|
||||
const pr = context.payload.pull_request;
|
||||
const { owner, repo } = context.repo;
|
||||
const headRepo = pr.head.repo?.full_name;
|
||||
// The API's status filter lags behind new runs: list the branch and check each one.
|
||||
const runs = await github.paginate(github.rest.actions.listWorkflowRunsForRepo, {
|
||||
owner,
|
||||
repo,
|
||||
branch: pr.head.ref,
|
||||
per_page: 100,
|
||||
});
|
||||
let cancelled = 0;
|
||||
for (const run of runs) {
|
||||
if (run.id === context.runId || run.status === 'completed') continue;
|
||||
if (run.head_repository?.full_name !== headRepo) continue;
|
||||
if (!['pull_request', 'pull_request_target'].includes(run.event)) continue;
|
||||
try {
|
||||
await github.rest.actions.cancelWorkflowRun({ owner, repo, run_id: run.id });
|
||||
cancelled++;
|
||||
} catch (e) {
|
||||
core.warning(`run ${run.id}: ${e.message}`);
|
||||
}
|
||||
}
|
||||
core.info(`Cancelled ${cancelled} run(s) of #${pr.number}`);
|
||||
@@ -5,7 +5,6 @@ on:
|
||||
pull_request:
|
||||
branches: [main]
|
||||
types: [opened, synchronize, reopened]
|
||||
merge_group:
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
@@ -13,9 +12,8 @@ permissions:
|
||||
|
||||
concurrency:
|
||||
group: ci-${{ github.ref }}
|
||||
# A newer push supersedes a pull request's run in progress. Runs on main and in the merge
|
||||
# queue finish, so a broken main shows up and the queue's required checks report.
|
||||
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
|
||||
# A newer push supersedes the run in progress, on main too.
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
@@ -25,7 +23,7 @@ env:
|
||||
|
||||
jobs:
|
||||
# Which parts a pull request touches, so jobs it can't affect skip and leave the
|
||||
# shared runners to others. Pushes, the merge queue and manual runs always run everything.
|
||||
# shared runners to others. Pushes and manual runs always run everything.
|
||||
changes:
|
||||
name: Changes
|
||||
runs-on: ubuntu-latest
|
||||
@@ -34,12 +32,7 @@ jobs:
|
||||
pull-requests: read
|
||||
outputs:
|
||||
rust: ${{ steps.classify.outputs.rust }}
|
||||
server: ${{ steps.classify.outputs.server }}
|
||||
plugins: ${{ steps.classify.outputs.plugins }}
|
||||
deny: ${{ steps.classify.outputs.deny }}
|
||||
frontend: ${{ steps.classify.outputs.frontend }}
|
||||
e2e: ${{ steps.classify.outputs.e2e }}
|
||||
catalog: ${{ steps.classify.outputs.catalog }}
|
||||
steps:
|
||||
- id: classify
|
||||
env:
|
||||
@@ -47,55 +40,26 @@ jobs:
|
||||
PR: ${{ github.event.pull_request.number }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
jobs="rust server plugins deny frontend e2e catalog"
|
||||
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
|
||||
for job in $jobs; do echo "$job=true" >> "$GITHUB_OUTPUT"; done
|
||||
echo "rust=true" >> "$GITHUB_OUTPUT"
|
||||
echo "frontend=true" >> "$GITHUB_OUTPUT"
|
||||
exit 0
|
||||
fi
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
|
||||
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
|
||||
cat files.txt
|
||||
# A change to CI itself runs everything.
|
||||
ci='^\.github/(workflows/ci\.yml|actions/)'
|
||||
docs='^(docs/|\.agents/|\.claude/|\.idea/|\.github/ISSUE_TEMPLATE/|\.github/pull_request_template\.md$|[^/]+\.md$|LICENSE$|NOTICE$)'
|
||||
# Frontend-only paths. The Rust code embeds a few files under src/; those stay out.
|
||||
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|evals/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
|
||||
web='^(src/|e2e/|perf/|public/|scripts/|smoke/|index\.html$|vite\.config\.ts$|tsconfig[^/]*\.json$|knip\.ts$|playwright\.config\.ts$|\.oxlintrc\.json$|\.oxfmtrc\.json$)'
|
||||
embedded='^src/(bindings\.ts|styles/tokens\.css|features/plugins/views/frame-bridge\.js|platform/keymaps/)'
|
||||
# Plugin web pages are their own pnpm projects, checked by the Plugins job only.
|
||||
plugin_web='^plugins/official/[^/]+/web-src/'
|
||||
# Paths the frontend checks never read...
|
||||
backend='^(crates/|src-tauri/|sdk/|wit/|java/|fixtures/|Cargo\.(toml|lock)$|deny\.toml$|rustfmt\.toml$|rust-toolchain(\.toml)?$|\.cargo/)'
|
||||
# ...except these, which frontend tests and e2e fixtures load.
|
||||
read_by_web='^(fixtures/(folding|django-app)/|crates/ide-plugin/tests/fixtures/|crates/ide-db/(src|tests/fixtures)/snowflake/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
|
||||
# What the browser app and its e2e tests are built from.
|
||||
app='^(src/|e2e/|public/|index\.html$|vite\.config\.ts$|tsconfig\.json$|playwright\.config\.ts$|package\.json$|pnpm-(lock|workspace)\.yaml$|crates/ide-plugin/tests/fixtures/|src-tauri/(icons|capabilities)/|src-tauri/tauri\.conf\.json$)'
|
||||
# The plugin workspaces: the SDK, the plugins, their interface and the host's fixture plugins.
|
||||
plugin_ws='^(sdk/|plugins/|wit/|crates/ide-plugin/tests/fixtures/|rust-toolchain(\.toml)?$)'
|
||||
# Never compiled into the openidea-server binary.
|
||||
not_server='^(src-tauri/|sdk/|fixtures/|crates/[^/]+/(tests|benches)/)'
|
||||
deps='(^|/)Cargo\.(toml|lock)$|^deny\.toml$'
|
||||
# The text catalog test reads the string literals of every Rust source.
|
||||
rust_source='^(crates|src-tauri/src)/.*\.rs$'
|
||||
|
||||
any() { grep -Eq "$1" files.txt; }
|
||||
outside() { [ -n "$(grep -Ev "$1" files.txt || true)" ]; }
|
||||
set_job() { echo "$1=$2" | tee -a "$GITHUB_OUTPUT"; }
|
||||
|
||||
if any "$ci"; then
|
||||
for job in $jobs; do set_job "$job" true; done
|
||||
exit 0
|
||||
fi
|
||||
on() { if "${@:2}"; then set_job "$1" true; else set_job "$1" false; fi; }
|
||||
rust_build() { outside "$1" || any "$embedded"; }
|
||||
web_checks() { outside "$docs|$plugin_web|$backend" || any "$read_by_web"; }
|
||||
catalog_only() { ! web_checks && any "$rust_source"; }
|
||||
on rust rust_build "$docs|$web|$plugin_web"
|
||||
on server rust_build "$docs|$web|$plugin_web|$not_server"
|
||||
on plugins any "$plugin_ws"
|
||||
on deny any "$deps"
|
||||
on frontend web_checks
|
||||
on e2e any "$app"
|
||||
on catalog catalog_only
|
||||
# A job runs when any changed file falls outside the paths that can't affect it.
|
||||
rust=false
|
||||
if grep -Ev "$docs|$web" files.txt | grep -q . || grep -Eq "$embedded" files.txt; then rust=true; fi
|
||||
frontend=false
|
||||
if grep -Ev "$docs" files.txt | grep -q .; then frontend=true; fi
|
||||
echo "rust=$rust frontend=$frontend"
|
||||
echo "rust=$rust" >> "$GITHUB_OUTPUT"
|
||||
echo "frontend=$frontend" >> "$GITHUB_OUTPUT"
|
||||
|
||||
rust:
|
||||
name: Rust (${{ matrix.os }})
|
||||
@@ -142,28 +106,12 @@ jobs:
|
||||
if: runner.os == 'Linux'
|
||||
run: git diff --exit-code src/bindings.ts src-tauri/tests/commands.snap
|
||||
|
||||
# One check that always reports, for the ruleset to require: a skipped matrix job reports
|
||||
# under its unexpanded name, so the per-OS checks never appear on frontend-only PRs.
|
||||
rust-checks:
|
||||
name: Rust checks
|
||||
needs: [changes, rust]
|
||||
if: always()
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- env:
|
||||
CHANGES: ${{ needs.changes.result }}
|
||||
RUST: ${{ needs.rust.result }}
|
||||
run: |
|
||||
echo "changes: $CHANGES, rust: $RUST"
|
||||
[ "$CHANGES" = success ] && { [ "$RUST" = success ] || [ "$RUST" = skipped ]; }
|
||||
|
||||
# The remote development server ships as a static Linux binary (release-build.yml):
|
||||
# keep that build working.
|
||||
server:
|
||||
name: Remote server (linux musl)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.server == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 40
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
@@ -181,7 +129,7 @@ jobs:
|
||||
plugins:
|
||||
name: Plugins (SDK, official, fixtures)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.plugins == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-22.04
|
||||
env:
|
||||
@@ -233,7 +181,7 @@ jobs:
|
||||
deny:
|
||||
name: Cargo deny
|
||||
needs: changes
|
||||
if: needs.changes.outputs.deny == 'true'
|
||||
if: needs.changes.outputs.rust == 'true'
|
||||
timeout-minutes: 15
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
@@ -262,26 +210,10 @@ jobs:
|
||||
- run: pnpm test
|
||||
- run: pnpm build
|
||||
|
||||
# A backend-only change can still drop a string the text catalog uses: run that one test.
|
||||
catalog:
|
||||
name: Text catalog
|
||||
needs: changes
|
||||
if: needs.changes.outputs.catalog == 'true'
|
||||
timeout-minutes: 15
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v5
|
||||
- uses: pnpm/action-setup@v5
|
||||
with: { version: 11 }
|
||||
- uses: actions/setup-node@v5
|
||||
with: { node-version: 22, cache: pnpm }
|
||||
- run: pnpm install --frozen-lockfile
|
||||
- run: pnpm vitest run src/platform/locales/textCatalog.test.ts
|
||||
|
||||
e2e:
|
||||
name: E2E (${{ matrix.shard }}/2)
|
||||
needs: changes
|
||||
if: needs.changes.outputs.e2e == 'true'
|
||||
if: needs.changes.outputs.frontend == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
|
||||
@@ -15,7 +15,6 @@ on:
|
||||
- "crates/**"
|
||||
- "languages/**"
|
||||
- "fixtures/**"
|
||||
- "java/**"
|
||||
- "Cargo.toml"
|
||||
- "Cargo.lock"
|
||||
- "src/features/run/**"
|
||||
@@ -42,77 +41,12 @@ env:
|
||||
CARGO_INCREMENTAL: 0
|
||||
|
||||
jobs:
|
||||
# The languages a pull request can affect: a change to one language's fixture, definition or
|
||||
# JDT LS bundle runs that language; crates the smoke doesn't exercise and other crates' tests
|
||||
# run none; anything else runs them all. Pushes and manual runs always run them all.
|
||||
changes:
|
||||
name: Changes
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
permissions:
|
||||
pull-requests: read
|
||||
outputs:
|
||||
languages: ${{ steps.classify.outputs.languages }}
|
||||
steps:
|
||||
- id: classify
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
PR: ${{ github.event.pull_request.number }}
|
||||
run: |
|
||||
set -euo pipefail
|
||||
all="typescript python rust go java kotlin php c cpp"
|
||||
emit() { tr ' ' '\n' <<< "$1" | { grep . || true; } | sort -u | jq -Rsc 'split("\n") | map(select(. != ""))'; }
|
||||
if [ "$GITHUB_EVENT_NAME" != pull_request ]; then
|
||||
echo "languages=$(emit "$all")" | tee -a "$GITHUB_OUTPUT"
|
||||
exit 0
|
||||
fi
|
||||
gh api --paginate "repos/$GITHUB_REPOSITORY/pulls/$PR/files" \
|
||||
--jq '.[] | .filename, (.previous_filename // empty)' > files.txt
|
||||
cat files.txt
|
||||
# Crates outside what the smoke runs (language servers, debuggers, run configurations,
|
||||
# SDKs, build tools and the project model): cargo metadata, deps of ide-lsp/dap/run/sdk/tools.
|
||||
unused='^crates/(ide-agent|ide-analysis|ide-android|ide-cli|ide-clipboard|ide-coverage|ide-db|ide-docker|ide-fonts|ide-github|ide-http|ide-mcp|ide-notebook|ide-profiler|ide-scaffold|ide-search|ide-spell|ide-ssh|ide-streams|ide-vcs|ide-web)/'
|
||||
# The workflow's paths, less those handled per language below.
|
||||
smoke='^(crates/|Cargo\.(toml|lock)$|src/features/(run|debugger)/|src/platform/|smoke/|package\.json$|pnpm-lock\.yaml$|\.github/workflows/language-smoke\.yml$|\.github/tool-versions\.env$)'
|
||||
langs=""
|
||||
while read -r f; do
|
||||
case "$f" in
|
||||
crates/ide-host/tests/language_smoke.rs | crates/ide-host/tests/project_smoke.rs) langs="$all"; break ;;
|
||||
crates/*/tests/* | crates/*/benches/*) ;;
|
||||
fixtures/ts-app/*) langs+=" typescript" ;;
|
||||
fixtures/python-app/*) langs+=" python" ;;
|
||||
fixtures/rust-app/*) langs+=" rust" ;;
|
||||
fixtures/go-app/*) langs+=" go" ;;
|
||||
fixtures/java-app/*) langs+=" java" ;;
|
||||
fixtures/kotlin-gradle/*) langs+=" kotlin" ;;
|
||||
fixtures/php-app/*) langs+=" php" ;;
|
||||
fixtures/c-app/*) langs+=" c cpp" ;;
|
||||
fixtures/*) ;;
|
||||
languages/typescript.toml | languages/typescriptreact.toml | languages/javascript.toml | languages/javascriptreact.toml) langs+=" typescript" ;;
|
||||
languages/python.toml) langs+=" python" ;;
|
||||
languages/rust.toml) langs+=" rust" ;;
|
||||
languages/go.toml | languages/gomod.toml | languages/gowork.toml) langs+=" go" ;;
|
||||
languages/java.toml) langs+=" java" ;;
|
||||
languages/kotlin.toml) langs+=" kotlin" ;;
|
||||
languages/php.toml) langs+=" php" ;;
|
||||
languages/c.toml) langs+=" c" ;;
|
||||
languages/cpp.toml) langs+=" cpp" ;;
|
||||
languages/*) ;;
|
||||
java/kotlin-bridge/*) langs+=" kotlin" ;;
|
||||
java/*) langs+=" java kotlin" ;;
|
||||
*) if grep -Eq "$smoke" <<< "$f" && ! grep -Eq "$unused" <<< "$f"; then langs="$all"; break; fi ;;
|
||||
esac
|
||||
done < files.txt
|
||||
echo "languages=$(emit "$langs")" | tee -a "$GITHUB_OUTPUT"
|
||||
|
||||
smoke:
|
||||
name: Language smoke (${{ matrix.language }})
|
||||
needs: changes
|
||||
if: needs.changes.outputs.languages != '[]'
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: ${{ fromJSON(needs.changes.outputs.languages) }}
|
||||
language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
|
||||
# C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
|
||||
runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || 'ubuntu-22.04' }}
|
||||
timeout-minutes: 40
|
||||
|
||||
Створено
-15
@@ -4319,7 +4319,6 @@ dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
"ide-http",
|
||||
"ide-sdk",
|
||||
"ide-ssh",
|
||||
"notify",
|
||||
"open",
|
||||
@@ -4341,7 +4340,6 @@ dependencies = [
|
||||
"tracing",
|
||||
"uuid",
|
||||
"zeroize",
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4378,17 +4376,6 @@ dependencies = [
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-flutter"
|
||||
version = "0.1.48"
|
||||
dependencies = [
|
||||
"ide-android",
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.48"
|
||||
@@ -4455,7 +4442,6 @@ dependencies = [
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-extension",
|
||||
"ide-flutter",
|
||||
"ide-heap",
|
||||
"ide-http",
|
||||
"ide-index",
|
||||
@@ -6748,7 +6734,6 @@ dependencies = [
|
||||
"tracing",
|
||||
"tracing-appender",
|
||||
"tracing-subscriber",
|
||||
"webkit2gtk",
|
||||
"webview2-com",
|
||||
"windows",
|
||||
"windows-sys 0.61.2",
|
||||
|
||||
@@ -194,36 +194,6 @@ declarations, key and animation binding names (`(keydown.enter)`, `[@fade]`,
|
||||
`(@fade.done)`), runs of text that entities split (`a && b`) parsed as one, and one
|
||||
token for `{` and `}`.
|
||||
|
||||
## Julia CodeMirror language support
|
||||
|
||||
[`@plutojl/lang-julia`](https://github.com/JuliaPluto/lang-julia) 1.2.0 and its
|
||||
[`@plutojl/lezer-julia`](https://github.com/JuliaPluto/lezer-julia) parser dependency
|
||||
provide the Julia CodeMirror 6 language mode. Both packages are MIT licensed;
|
||||
the full license text is below. The mode wraps a Lezer grammar and exposes its
|
||||
syntax tags through `julia()`.
|
||||
|
||||
### MIT License (@plutojl/lang-julia and @plutojl/lezer-julia)
|
||||
|
||||
Copyright (c) 2021 Andrey Popp
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
## nvim-treesitter queries
|
||||
|
||||
`crates/ide-syntax/queries/<grammar>/locals.scm` are derived from the `locals.scm`
|
||||
|
||||
@@ -203,11 +203,7 @@ async fn a_task_runs_on_a_v2_agent_and_resumes_its_session() {
|
||||
let agent2 = Arc::new(FakeV2Agent::default());
|
||||
let mgr2 = manager(tmp.path(), agent2.clone());
|
||||
mgr2.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
// The task is Ready until the resumed turn starts: wait for the turn's entries first.
|
||||
let deadline = std::time::Instant::now() + Duration::from_secs(10);
|
||||
while mgr2.entries(&task.id, None).unwrap().len() < 8 && std::time::Instant::now() < deadline {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
wait_for(&mgr2, &task.id, AgentStatus::Ready).await;
|
||||
let entries = mgr2.entries(&task.id, None).unwrap();
|
||||
assert_eq!(summary(&entries[6..]), ["user: again", "agent: second turn"]);
|
||||
|
||||
@@ -213,31 +213,6 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
/// Availability for an explicit session switch must come from a recent discovery for this
|
||||
/// launch, not from the display fallback or a different project's session report.
|
||||
pub(super) fn fresh_model(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
spec: &provider::ProviderSpec,
|
||||
model: &str,
|
||||
) -> Option<crate::AgentConfigValue> {
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
let select = |catalog: &CatalogData| {
|
||||
let age = self.epoch_ms() - catalog.refreshed_at_ms?;
|
||||
if !(0.0..FRESH_FOR.as_millis() as f64).contains(&age) {
|
||||
return None;
|
||||
}
|
||||
catalog.model_option()?.values.iter().find(|value| value.value == model).cloned()
|
||||
};
|
||||
let state = self.state.lock();
|
||||
if let Some(entry) = state.entries.get(&Self::key(shared, &spec.id)) {
|
||||
return select(entry.catalog.as_ref().filter(|_| entry.context == context)?);
|
||||
}
|
||||
let cache = shared.known.lock();
|
||||
let saved = cache.get(&spec.id)?.catalogs.get(&shared.root_key())?;
|
||||
(saved.fingerprint == context.fingerprint()).then(|| select(&saved.catalog)).flatten()
|
||||
}
|
||||
|
||||
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())
|
||||
|
||||
@@ -11,7 +11,6 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
launch: usize,
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
@@ -45,7 +44,7 @@ impl Harness {
|
||||
let launches = launches.clone();
|
||||
let live = live.clone();
|
||||
move |_, _, client, _| {
|
||||
let launch = launches.fetch_add(1, Ordering::SeqCst);
|
||||
launches.fetch_add(1, Ordering::SeqCst);
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
@@ -76,17 +75,10 @@ impl Harness {
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new"
|
||||
| "session/set_config_option"
|
||||
| "session/set_model"
|
||||
| "session/load"
|
||||
| "session/resume"
|
||||
| "session/prompt"
|
||||
| "session/set_mode" => {
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
launch,
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
@@ -298,223 +290,6 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_confirmed_by_the_live_session() {
|
||||
switch_chat_model(ChatSwitch::Live).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_reloads_the_same_session_on_the_next_message() {
|
||||
switch_chat_model(ChatSwitch::Resume).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_leaves_the_original_session_intact_after_resume_failure() {
|
||||
switch_chat_model(ChatSwitch::ResumeFails).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_is_reverted_when_the_reloaded_session_does_not_offer_it() {
|
||||
switch_chat_model(ChatSwitch::Unavailable).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
|
||||
switch_chat_model(ChatSwitch::Idle).await;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum ChatSwitch {
|
||||
Live,
|
||||
Resume,
|
||||
ResumeFails,
|
||||
Unavailable,
|
||||
Idle,
|
||||
}
|
||||
|
||||
async fn switch_chat_model(scenario: ChatSwitch) {
|
||||
use crate::{AgentPrompt, AgentStatus, Isolation, NewAgentTask};
|
||||
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 1, "agentCapabilities": { "loadSession": true }
|
||||
}));
|
||||
let mut manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let task = manager
|
||||
.create(NewAgentTask {
|
||||
prompt: AgentPrompt { text: "first".into(), ..Default::default() },
|
||||
provider: PROVIDER.into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/new"));
|
||||
let mut initial = response(&["old"], &["low", "high"]);
|
||||
initial["sessionId"] = json!("saved-chat");
|
||||
initial["modes"] = json!({
|
||||
"currentModeId": "code", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]
|
||||
});
|
||||
next.reply.send(Ok(initial.clone())).unwrap();
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(0, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
{
|
||||
let mode = manager.set_config(&task.id, "mode", "ask".into());
|
||||
tokio::pin!(mode);
|
||||
let set = next_chat_request(&mut harness, mode.as_mut()).await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (0, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
mode.await.unwrap();
|
||||
}
|
||||
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
|
||||
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
|
||||
if matches!(scenario, ChatSwitch::Idle) {
|
||||
manager.shutdown();
|
||||
manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
}
|
||||
|
||||
let mut events = events(&manager);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let next = harness.next().await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
|
||||
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
|
||||
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
|
||||
|
||||
let live = matches!(scenario, ChatSwitch::Live);
|
||||
let offline = matches!(scenario, ChatSwitch::Idle);
|
||||
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
|
||||
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
|
||||
let switching = manager.set_config(&task.id, "model", "new".into());
|
||||
tokio::pin!(switching);
|
||||
if !offline {
|
||||
let next = next_chat_request(&mut harness, switching.as_mut()).await;
|
||||
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
|
||||
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
if live {
|
||||
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
} else {
|
||||
next.reply.send(Err("not in this process's model list".into())).unwrap();
|
||||
}
|
||||
}
|
||||
// A fallback selection settles without waiting for a new process.
|
||||
tokio::select! {
|
||||
result = &mut switching => result.unwrap(),
|
||||
request = harness.next() => panic!("selection must not open another session: {request:?}"),
|
||||
}
|
||||
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
|
||||
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
|
||||
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
|
||||
|
||||
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
|
||||
if !live {
|
||||
let load = harness.next().await;
|
||||
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
|
||||
assert_eq!(load.params["sessionId"], "saved-chat");
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "agent_message_chunk", "content": {"type": "text", "text": "replay"}}
|
||||
}}))
|
||||
.unwrap();
|
||||
if load_fails {
|
||||
load.notifications
|
||||
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": "saved-chat",
|
||||
"update": {"sessionUpdate": "config_option_update",
|
||||
"configOptions": response(&["other", "old"], &["low"])["configOptions"]}
|
||||
}}))
|
||||
.unwrap();
|
||||
load.reply.send(Err("cannot resume saved-chat".into())).unwrap();
|
||||
} else {
|
||||
let models: &[&str] = if unavailable { &["old"] } else { &["old", "new"] };
|
||||
let mut resumed = response(models, &["low", "high"]);
|
||||
resumed["modes"] = initial["modes"].clone();
|
||||
load.reply.send(Ok(resumed)).unwrap();
|
||||
}
|
||||
if load_fails || unavailable {
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
|
||||
let task = snapshot(&manager);
|
||||
assert_eq!(task.model.as_deref(), Some("old"));
|
||||
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
|
||||
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
|
||||
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
|
||||
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
|
||||
if load_fails {
|
||||
manager
|
||||
.prompt(&task.id, AgentPrompt { text: "retry".into(), ..Default::default() }, false)
|
||||
.await
|
||||
.unwrap();
|
||||
let retry = harness.next().await;
|
||||
assert_eq!((retry.launch, retry.method.as_str()), (3, "session/load"));
|
||||
assert_eq!(retry.params["sessionId"], "saved-chat");
|
||||
retry.reply.send(Ok(initial.clone())).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!(set.method, "session/set_mode");
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
let prompt = harness.next().await;
|
||||
assert_eq!(prompt.method, "session/prompt");
|
||||
assert_eq!(prompt.params["sessionId"], "saved-chat");
|
||||
prompt.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
manager.shutdown();
|
||||
return;
|
||||
}
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
|
||||
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
|
||||
let set = harness.next().await;
|
||||
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
|
||||
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
|
||||
set.reply.send(Ok(json!({}))).unwrap();
|
||||
}
|
||||
let next = harness.next().await;
|
||||
assert_eq!(
|
||||
(next.launch, next.method.as_str(), &next.params["sessionId"]),
|
||||
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
|
||||
);
|
||||
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
|
||||
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
|
||||
let current = snapshot(&manager);
|
||||
assert_eq!(current.model.as_deref(), Some("new"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
|
||||
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
|
||||
manager.shutdown();
|
||||
}
|
||||
|
||||
async fn wait_for_chat(manager: &AgentManager, id: &str, status: crate::AgentStatus) {
|
||||
let task = manager.task(id).unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while task.state.lock().task.status != status || task.state.lock().busy {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
async fn next_chat_request(
|
||||
harness: &mut Harness,
|
||||
switching: std::pin::Pin<&mut impl Future<Output = crate::IdeResult<()>>>,
|
||||
) -> Pending {
|
||||
tokio::select! {
|
||||
result = switching => panic!("model switching ended before contacting the session: {result:?}"),
|
||||
request = harness.next() => request,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -219,23 +219,6 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
|
||||
}
|
||||
}
|
||||
|
||||
/// Legacy setters and agents that report the change in a notification may return no model.
|
||||
pub(super) fn accepts_model(reply: &Value, id: &str, value: &str) -> bool {
|
||||
reply
|
||||
.get("configOptions")
|
||||
.and_then(Value::as_array)
|
||||
.and_then(|options| {
|
||||
options.iter().find(|option| {
|
||||
option.get("category").and_then(Value::as_str) == Some("model")
|
||||
|| option.get("id").or_else(|| option.get("configId")).and_then(Value::as_str) == Some(id)
|
||||
})
|
||||
})
|
||||
.and_then(|option| option.get("currentValue"))
|
||||
.or_else(|| reply.pointer("/models/currentModelId"))
|
||||
.and_then(Value::as_str)
|
||||
.is_none_or(|current| current == value)
|
||||
}
|
||||
|
||||
/// `available_commands_update`.
|
||||
pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
|
||||
update
|
||||
|
||||
@@ -20,7 +20,6 @@ mod native;
|
||||
mod provider;
|
||||
pub mod registry;
|
||||
pub mod security;
|
||||
mod shell;
|
||||
mod skills;
|
||||
mod timeline;
|
||||
mod worktree;
|
||||
@@ -125,9 +124,6 @@ type Connector = Arc<
|
||||
/// Returns the configured MCP servers (User and Workspace) for this project.
|
||||
pub type McpServersFn = dyn Fn() -> Vec<McpServer> + Send + Sync;
|
||||
|
||||
/// Returns the executable of the running built-in MCP server, if any.
|
||||
pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
@@ -151,7 +147,6 @@ struct Shared {
|
||||
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
mcp_executable_hook: RwLock<Option<Arc<McpExecutableFn>>>,
|
||||
/// Monotonic id for [`AgentEvent::Attention`] episodes.
|
||||
attention_seq: AtomicU64,
|
||||
}
|
||||
@@ -224,12 +219,8 @@ impl Shared {
|
||||
overrides: &BTreeMap<String, bool>,
|
||||
) -> McpForSession {
|
||||
let builtin_off = overrides.get(mcp::BUILTIN_MCP_NAME) == Some(&false);
|
||||
let mut servers = if builtin_off {
|
||||
Vec::new()
|
||||
} else {
|
||||
let exe = self.mcp_executable_hook.read().as_ref().and_then(|hook| hook());
|
||||
stdio_mcp_servers(exe.as_deref(), init.mcp_stdio(), &self.paths.project_root)
|
||||
};
|
||||
let mut servers =
|
||||
if builtin_off { Vec::new() } else { mcp_servers_for(init.mcp_stdio(), &self.paths.project_root) };
|
||||
let configured = self.mcp_servers_hook.read().as_ref().map(|hook| hook()).unwrap_or_default();
|
||||
servers.extend(mcp::acp_mcp_servers(&configured, provider, init, overrides));
|
||||
let off = Self::mcp_off(&configured, provider, overrides);
|
||||
@@ -357,9 +348,6 @@ struct TaskFile {
|
||||
/// Settings the user chose, re-applied to every new or reloaded session.
|
||||
#[serde(default)]
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pending_model: Option<String>,
|
||||
/// In the project's own checkout: files already changed when the task started.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
before: BTreeMap<String, worktree::Stamp>,
|
||||
@@ -371,9 +359,6 @@ struct TaskFile {
|
||||
/// `None` for a worktree task, and a task saved before these were recorded.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
touched: Option<BTreeSet<String>>,
|
||||
/// The checkout as the last turn started, its copies in the store's `<id>.turn` folder.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
turn: Option<worktree::TurnStart>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
subagents: Vec<SavedSubagent>,
|
||||
/// Turns to drop from the session once it is loaded (a fork of an earlier point).
|
||||
@@ -392,14 +377,11 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
pending_model: Option<String>,
|
||||
model_choice: u64,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
touched: Option<Arc<BTreeSet<String>>>,
|
||||
/// See `TaskFile::turn`.
|
||||
turn: Option<Arc<worktree::TurnStart>>,
|
||||
pending_rollback: u32,
|
||||
/// The user named the task; see `TaskFile::title_renamed`.
|
||||
title_renamed: bool,
|
||||
@@ -409,27 +391,6 @@ struct TaskState {
|
||||
/// the like), as it sent them: unlike a turn they outlive it, so an idle release
|
||||
/// waits for the last one. A (re)started process runs nothing yet.
|
||||
background_tasks: Vec<Value>,
|
||||
/// Shell commands the user ran with `!` since the last prompt, as the text block that
|
||||
/// goes ahead of the next one.
|
||||
shell_context: Vec<String>,
|
||||
}
|
||||
|
||||
impl TaskState {
|
||||
fn pending_model(&self) -> Option<&AgentConfigChoice> {
|
||||
let id = self.pending_model.as_deref()?;
|
||||
self.wanted.iter().find(|c| c.id == id)
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> AgentTask {
|
||||
let mut task = self.task.clone();
|
||||
if let Some(choice) = self.pending_model()
|
||||
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
|
||||
{
|
||||
model.current = Some(choice.value.clone());
|
||||
task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
task
|
||||
}
|
||||
}
|
||||
|
||||
/// A running agent and its session.
|
||||
@@ -524,7 +485,6 @@ impl AgentManager {
|
||||
copilot_acp_fallback: Mutex::new(HashSet::new()),
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
mcp_executable_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
});
|
||||
shared.paths.catalogs.subscribe(&shared);
|
||||
@@ -559,7 +519,7 @@ impl AgentManager {
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().task.clone()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
@@ -659,11 +619,6 @@ impl AgentManager {
|
||||
*self.shared.mcp_servers_hook.write() = Some(Arc::from(hook));
|
||||
}
|
||||
|
||||
/// Provides the executable of the running built-in MCP server for this host.
|
||||
pub fn set_mcp_executable_hook(&self, hook: Box<McpExecutableFn>) {
|
||||
*self.shared.mcp_executable_hook.write() = Some(Arc::from(hook));
|
||||
}
|
||||
|
||||
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
|
||||
/// in the project: what the agent offered last time there, unadvertised builtins,
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed.
|
||||
@@ -795,11 +750,9 @@ impl AgentManager {
|
||||
session_id: Some(session_id.to_owned()),
|
||||
entries: Vec::new(),
|
||||
wanted: Vec::new(),
|
||||
pending_model: None,
|
||||
before: BTreeMap::new(),
|
||||
saved: None,
|
||||
touched: Some(BTreeSet::new()),
|
||||
turn: None,
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: true,
|
||||
@@ -910,11 +863,9 @@ impl AgentManager {
|
||||
session_id: None,
|
||||
entries: Vec::new(),
|
||||
wanted: req.config,
|
||||
pending_model: None,
|
||||
before,
|
||||
saved,
|
||||
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
|
||||
turn: None,
|
||||
subagents: Vec::new(),
|
||||
pending_rollback: 0,
|
||||
title_renamed: false,
|
||||
@@ -975,26 +926,6 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Runs `command` (a composer line starting with `!`) in the task's folder with the user's
|
||||
/// shell, without starting a turn: it shows as one entry with its output and exit code,
|
||||
/// and goes to the agent with the next message.
|
||||
pub async fn run_shell(&self, id: &str, command: &str, cancel: ide_core::CancellationToken) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let command = command.trim();
|
||||
if command.is_empty() {
|
||||
return Err(IdeError::invalid("empty command"));
|
||||
}
|
||||
let cwd = {
|
||||
let s = task.state.lock();
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
s.task.cwd.0.clone()
|
||||
};
|
||||
task.shell(command, &cwd, &cancel).await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Drops a queued message.
|
||||
pub fn unqueue(&self, id: &str, queued: &str) -> IdeResult<AgentQueued> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1063,7 +994,7 @@ 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, change) = {
|
||||
let (target, model_choice, previous_levels) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
@@ -1073,28 +1004,22 @@ impl AgentManager {
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
(target, None)
|
||||
} else {
|
||||
let switching_model = target.category.as_deref() == Some("model");
|
||||
if switching_model {
|
||||
s.model_choice += 1;
|
||||
s.pending_model = None;
|
||||
}
|
||||
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
|
||||
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
|
||||
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, Some((s.model_choice, previous_levels)))
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
};
|
||||
let Some((model_choice, previous_levels)) = change else {
|
||||
return task.switch_discovered_model(target, value).await;
|
||||
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
|
||||
@@ -1261,12 +1186,9 @@ impl AgentManager {
|
||||
session_id: Some(session),
|
||||
entries,
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: None,
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
// The source's next turn replaces its copies: the fork's last turn is one of its own.
|
||||
turn: None,
|
||||
subagents: s.conversation.saved_subagents(),
|
||||
pending_rollback: total - keep,
|
||||
title_renamed: s.title_renamed,
|
||||
@@ -1306,7 +1228,6 @@ impl AgentManager {
|
||||
_ => None,
|
||||
};
|
||||
s.session_id = None;
|
||||
s.pending_model = None;
|
||||
s.conversation = Conversation::default();
|
||||
// The fresh session reports its own usage; nothing carries over.
|
||||
s.task.usage = None;
|
||||
@@ -1607,7 +1528,6 @@ impl AgentManager {
|
||||
self.tasks.write().remove(id);
|
||||
*task.deleted.lock() = true;
|
||||
let _ = std::fs::remove_file(self.shared.paths.store_dir.join(format!("{id}.json")));
|
||||
let _ = std::fs::remove_dir_all(task.turn_dir());
|
||||
let saved = task.state.lock().saved.clone();
|
||||
if let Some(saved) = saved
|
||||
&& !self.tasks.read().values().any(|t| t.state.lock().saved.as_ref() == Some(&saved))
|
||||
@@ -1650,47 +1570,18 @@ impl AgentManager {
|
||||
.await
|
||||
}
|
||||
|
||||
/// The files the task's last turn changed, against the checkout as it started (while a
|
||||
/// turn runs: that turn's so far). None before the task's first turn.
|
||||
pub async fn turn_changes(&self, id: &str) -> IdeResult<Vec<AgentChange>> {
|
||||
let (cwd, turn, dir) = self.task(id)?.last_turn();
|
||||
let Some(turn) = turn else { return Ok(Vec::new()) };
|
||||
blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
};
|
||||
worktree::turn_changes(&cwd, &turn, &dir, &changed)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Content of `path` (in the task's directory) as `view` compares it: when the task
|
||||
/// started, in `HEAD`, or when the last turn started.
|
||||
pub async fn base_text(&self, id: &str, path: PathBuf, view: AgentChangesView) -> IdeResult<Option<String>> {
|
||||
let task = self.task(id)?;
|
||||
if view == AgentChangesView::LastTurn {
|
||||
let (cwd, turn, dir) = task.last_turn();
|
||||
let Some(turn) = turn else { return Ok(None) };
|
||||
return blocking(move || worktree::turn_text(&cwd, &path, &turn, &dir)).await;
|
||||
}
|
||||
let at = task.base();
|
||||
blocking(move || {
|
||||
let rev = match view {
|
||||
AgentChangesView::Group => worktree::head_commit(at.cwd())?,
|
||||
_ => at.rev()?,
|
||||
};
|
||||
match rev {
|
||||
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
|
||||
None => Ok(None),
|
||||
}
|
||||
/// Content of `path` (in the task's directory) when the task started.
|
||||
pub async fn base_text(&self, id: &str, path: PathBuf) -> IdeResult<Option<String>> {
|
||||
let at = self.task(id)?.base();
|
||||
blocking(move || match at.rev()? {
|
||||
Some(rev) => worktree::file_at(at.cwd(), &path, &rev),
|
||||
None => Ok(None),
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Rollback: puts the task's changed files among `rel_paths` (all with `None`) back as
|
||||
/// `view` compares them: as they were when it started, as they are in `HEAD`, or as they
|
||||
/// were when its last turn started.
|
||||
/// `view` compares them: as they were when it started, or as they are in `HEAD`.
|
||||
pub async fn rollback_changes(
|
||||
&self,
|
||||
id: &str,
|
||||
@@ -1701,18 +1592,15 @@ impl AgentManager {
|
||||
if task.state.lock().busy {
|
||||
return Err(IdeError::invalid("the agent is working: stop it before rolling back its changes"));
|
||||
}
|
||||
if view == AgentChangesView::LastTurn {
|
||||
return self.rollback_turn(&task, rel_paths).await;
|
||||
}
|
||||
let at = task.base();
|
||||
let (before, saved, touched) = {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)), s.touched.clone())
|
||||
};
|
||||
let (restamped, restored) = blocking(move || {
|
||||
let restamped = blocking(move || {
|
||||
let (changes, rev) = match view {
|
||||
AgentChangesView::Group => (at.grouped_changes(&before)?.uncommitted, worktree::head_commit(at.cwd())?),
|
||||
AgentChangesView::SinceStart | AgentChangesView::LastTurn => (at.changes(&before)?, at.rev()?),
|
||||
AgentChangesView::SinceStart => (at.changes(&before)?, at.rev()?),
|
||||
};
|
||||
let changes = worktree::made_by_task(changes, touched.as_deref());
|
||||
let sources = match rev.as_deref() {
|
||||
@@ -1720,7 +1608,6 @@ impl AgentManager {
|
||||
None => Default::default(),
|
||||
};
|
||||
let mut restamped = Vec::new();
|
||||
let mut restored = Vec::new();
|
||||
for change in changes.iter().filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path))) {
|
||||
// A rename goes back to its old path too; the new one is taken away first, so a
|
||||
// case-only rename on a case-insensitive disk ends as the old file.
|
||||
@@ -1730,58 +1617,6 @@ impl AgentManager {
|
||||
if before.contains_key(&change.rel_path) {
|
||||
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
|
||||
}
|
||||
restored.push(change.rel_path.clone());
|
||||
}
|
||||
}
|
||||
Ok((restamped, restored))
|
||||
})
|
||||
.await?;
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !restamped.is_empty() {
|
||||
let mut before = (*s.before).clone();
|
||||
before.extend(restamped);
|
||||
s.before = Arc::new(before);
|
||||
}
|
||||
// Rolled back further than the last turn: what it changed there is gone, not the turn's to list.
|
||||
if let Some(turn) = &s.turn
|
||||
&& let Some(changed) = &turn.changed
|
||||
&& restored.iter().any(|rel| changed.contains(rel))
|
||||
{
|
||||
let changed = changed.iter().filter(|rel| !restored.contains(rel)).cloned().collect();
|
||||
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(changed), ..(**turn).clone() }));
|
||||
}
|
||||
}
|
||||
task.persist();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Puts the last turn's changed files among `rel_paths` (all with `None`) back as they
|
||||
/// were when it started.
|
||||
async fn rollback_turn(&self, task: &Task, rel_paths: Option<Vec<String>>) -> IdeResult<()> {
|
||||
let (cwd, turn, dir) = task.last_turn();
|
||||
let Some(turn) = turn else { return Ok(()) };
|
||||
let (before, saved) = {
|
||||
let s = task.state.lock();
|
||||
(s.before.clone(), s.saved.as_ref().map(|name| self.shared.paths.store_dir.join(name)))
|
||||
};
|
||||
let restamped = blocking(move || {
|
||||
let changed = match &turn.changed {
|
||||
Some(changed) => changed.clone(),
|
||||
None => worktree::changed_in_turn(&cwd, &turn)?.1,
|
||||
};
|
||||
let mut restamped = Vec::new();
|
||||
for change in worktree::turn_changes(&cwd, &turn, &dir, &changed)?
|
||||
.iter()
|
||||
.filter(|c| rel_paths.as_ref().is_none_or(|p| p.contains(&c.rel_path)))
|
||||
{
|
||||
worktree::restore_turn(&cwd, &turn, &dir, change)?;
|
||||
// Back to the user's own edits from before the task: not a change of the task.
|
||||
if let Some(Some(_)) = before.get(&change.rel_path)
|
||||
&& let Some(copy) = saved.as_deref().and_then(|d| worktree::saved_copy(d, &change.rel_path))
|
||||
&& std::fs::read(&change.path.0).is_ok_and(|now| now == copy)
|
||||
{
|
||||
restamped.push((change.rel_path.clone(), worktree::stamp(&change.path.0)));
|
||||
}
|
||||
}
|
||||
Ok(restamped)
|
||||
@@ -1855,7 +1690,7 @@ impl AgentManager {
|
||||
s.task.mcp_overrides = cleaned;
|
||||
s.task.updated_ms = now_ms();
|
||||
}
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.snapshot())
|
||||
(changed, s.busy, !s.background_tasks.is_empty(), s.task.clone())
|
||||
};
|
||||
if changed {
|
||||
task.persist();
|
||||
@@ -1913,17 +1748,14 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
pending_model: file.pending_model,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
turn: file.turn.map(Arc::new),
|
||||
pending_rollback: file.pending_rollback,
|
||||
title_renamed: file.title_renamed,
|
||||
busy: false,
|
||||
background_tasks: Vec::new(),
|
||||
shell_context: Vec::new(),
|
||||
}),
|
||||
live: Mutex::new(None),
|
||||
connecting: tokio::sync::Mutex::new(()),
|
||||
@@ -1953,48 +1785,31 @@ impl Task {
|
||||
(s.before.clone(), s.touched.clone())
|
||||
}
|
||||
|
||||
/// Where the copies of the files already changed as the last turn started are kept.
|
||||
fn turn_dir(&self) -> PathBuf {
|
||||
self.shared.paths.store_dir.join(format!("{}.turn", self.id))
|
||||
}
|
||||
|
||||
/// The checkout as the last turn started, with the folder of its copies.
|
||||
fn last_turn(&self) -> (PathBuf, Option<Arc<worktree::TurnStart>>, PathBuf) {
|
||||
let s = self.state.lock();
|
||||
(s.task.cwd.0.clone(), s.turn.clone(), self.turn_dir())
|
||||
}
|
||||
|
||||
/// Records the checkout as a turn starts: what the turn's changes are compared with.
|
||||
async fn checkout_before_turn(&self) {
|
||||
let (cwd, previous, dir) = self.last_turn();
|
||||
let turn = match blocking(move || worktree::start_turn(&cwd, &dir, previous.as_deref())).await {
|
||||
Ok(turn) => Some(Arc::new(turn)),
|
||||
Err(e) => {
|
||||
tracing::warn!("recording the checkout as a turn of agent task {} starts: {e}", self.id);
|
||||
None
|
||||
}
|
||||
/// The changed files of the checkout as a turn starts, when the task records what its turns change.
|
||||
async fn checkout_before_turn(&self) -> Option<Snapshot> {
|
||||
let cwd = {
|
||||
let s = self.state.lock();
|
||||
s.touched.as_ref()?;
|
||||
s.task.cwd.0.clone()
|
||||
};
|
||||
self.state.lock().turn = turn;
|
||||
self.persist();
|
||||
blocking(move || worktree::snapshot(&cwd)).await.ok()
|
||||
}
|
||||
|
||||
/// Records the files that changed in the checkout while the turn ran: the turn's, and in
|
||||
/// the project's own checkout also the task's.
|
||||
async fn record_turn_changes(&self) {
|
||||
let (cwd, turn, _) = self.last_turn();
|
||||
let Some(turn) = turn else { return };
|
||||
let start = turn.clone();
|
||||
let Ok((in_worktree, all)) = blocking(move || worktree::changed_in_turn(&cwd, &start)).await else { return };
|
||||
/// Records the files that changed in the checkout since `start`, as the turn ends, as the task's.
|
||||
async fn record_turn_changes(&self, start: Option<Snapshot>) {
|
||||
let Some(start) = start else { return };
|
||||
let cwd = self.state.lock().task.cwd.0.clone();
|
||||
let Ok(end) = blocking(move || worktree::snapshot(&cwd)).await else { return };
|
||||
let changed = worktree::changed_between(&start, &end);
|
||||
if changed.is_empty() {
|
||||
return;
|
||||
}
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if !in_worktree.is_empty()
|
||||
&& let Some(touched) = &s.touched
|
||||
{
|
||||
let mut touched = (**touched).clone();
|
||||
touched.extend(in_worktree);
|
||||
s.touched = Some(Arc::new(touched));
|
||||
}
|
||||
s.turn = Some(Arc::new(worktree::TurnStart { changed: Some(all), ..(*turn).clone() }));
|
||||
let Some(touched) = &s.touched else { return };
|
||||
let mut touched = (**touched).clone();
|
||||
touched.extend(changed);
|
||||
s.touched = Some(Arc::new(touched));
|
||||
}
|
||||
self.persist();
|
||||
}
|
||||
@@ -2011,7 +1826,7 @@ impl Task {
|
||||
}
|
||||
|
||||
fn emit_task(&self) {
|
||||
let task = self.state.lock().snapshot();
|
||||
let task = self.state.lock().task.clone();
|
||||
self.shared.emit(AgentEvent::Task { task: Box::new(task) });
|
||||
}
|
||||
|
||||
@@ -2108,11 +1923,9 @@ impl Task {
|
||||
session_id: s.session_id.clone(),
|
||||
entries: s.conversation.main.entries.clone(),
|
||||
wanted: s.wanted.clone(),
|
||||
pending_model: s.pending_model.clone(),
|
||||
before: (*s.before).clone(),
|
||||
saved: s.saved.clone(),
|
||||
touched: s.touched.as_deref().cloned(),
|
||||
turn: s.turn.as_deref().cloned(),
|
||||
subagents: s.conversation.saved_subagents(),
|
||||
pending_rollback: s.pending_rollback,
|
||||
title_renamed: s.title_renamed,
|
||||
@@ -2154,33 +1967,6 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Folds an update made here (not by the agent) into the main conversation.
|
||||
fn apply_local(self: &Arc<Self>, update: &Value) {
|
||||
let changed = self.state.lock().conversation.apply(None, update, now_ms());
|
||||
self.mark_dirty(changed);
|
||||
}
|
||||
|
||||
async fn shell(self: &Arc<Self>, command: &str, cwd: &Path, cancel: &ide_core::CancellationToken) {
|
||||
let call = format!("shell-{}", uuid::Uuid::new_v4().simple());
|
||||
self.apply_local(&json!({
|
||||
"sessionUpdate": "tool_call",
|
||||
"toolCallId": call,
|
||||
"title": format!("! {command}"),
|
||||
"kind": "execute",
|
||||
"status": "in_progress",
|
||||
}));
|
||||
let ran = shell::run(command, cwd, cancel).await;
|
||||
let status = if ran.code == Some(0) { "completed" } else { "failed" };
|
||||
self.apply_local(&json!({
|
||||
"sessionUpdate": "tool_call_update",
|
||||
"toolCallId": call,
|
||||
"status": status,
|
||||
"content": [{ "type": "content", "content": { "type": "text", "text": ran.shown() } }],
|
||||
}));
|
||||
self.state.lock().shell_context.push(ran.context(command));
|
||||
self.persist();
|
||||
}
|
||||
|
||||
fn push_entry(self: &Arc<Self>, entry: AgentEntry) -> usize {
|
||||
let i = self.state.lock().conversation.main.push(entry);
|
||||
self.mark_dirty([(None, i)]);
|
||||
@@ -2191,11 +1977,11 @@ impl Task {
|
||||
/// the user stops one. The caller set `busy`.
|
||||
async fn run(self: Arc<Self>, mut prompt: AgentPrompt) {
|
||||
loop {
|
||||
self.checkout_before_turn().await;
|
||||
let start = self.checkout_before_turn().await;
|
||||
let result = self.turn(&prompt).await;
|
||||
self.cancel_pending.store(false, Ordering::Release);
|
||||
tokio::time::sleep(TURN_GRACE).await;
|
||||
self.record_turn_changes().await;
|
||||
self.record_turn_changes(start).await;
|
||||
let changed = self.state.lock().conversation.end_turn(Some(now_ms()));
|
||||
self.mark_dirty(changed);
|
||||
let send_now = self.send_now.swap(false, Ordering::AcqRel);
|
||||
@@ -2241,7 +2027,7 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops an idle resumable live session so the next turn reloads it.
|
||||
/// Drops an idle resumable live session so the next turn reloads it with fresh MCP servers.
|
||||
fn recycle_resumable_session(&self) {
|
||||
self.mcp_reload_pending.store(false, Ordering::Release);
|
||||
let live = {
|
||||
@@ -2249,110 +2035,12 @@ impl Task {
|
||||
if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
|
||||
};
|
||||
if let Some(live) = live {
|
||||
tracing::debug!("agent task {}: recycling idle resumable session", self.id);
|
||||
tracing::debug!("agent task {}: restarting idle resumable session for MCP override update", self.id);
|
||||
live.peer.kill();
|
||||
self.clear_shown_background();
|
||||
}
|
||||
}
|
||||
|
||||
async fn switch_discovered_model(&self, target: AgentConfigOption, value: String) -> IdeResult<()> {
|
||||
let provider = self.state.lock().task.provider.clone();
|
||||
let spec = self.shared.spec(&provider).ok_or_else(|| IdeError::not_found("no such agent"))?;
|
||||
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
|
||||
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
|
||||
})?;
|
||||
let model_choice = {
|
||||
let mut s = self.state.lock();
|
||||
s.model_choice += 1;
|
||||
s.model_choice
|
||||
};
|
||||
// A prompt starting during the switch must not grab the peer we're about to recycle.
|
||||
let _connecting = self.connecting.lock().await;
|
||||
{
|
||||
let s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
}
|
||||
let live = self.live.lock().clone();
|
||||
let result = if let Some(live) = live.as_ref().filter(|l| !l.peer.is_closed()) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
match live.peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) if config::accepts_model(&reply, &target.id, &value) => Ok(Some(reply)),
|
||||
Ok(_) => Err(format!("The agent did not switch to model {value}.")),
|
||||
Err(e) => Err(self.describe(e)),
|
||||
}
|
||||
} else {
|
||||
Ok(None)
|
||||
};
|
||||
|
||||
let accepted = {
|
||||
let mut s = self.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if s.task.status == AgentStatus::Archived {
|
||||
return Err(IdeError::invalid("the task is archived"));
|
||||
}
|
||||
let pending = match result {
|
||||
Ok(Some(reply)) => {
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut s.task.config, options);
|
||||
} else if s.task.model.as_deref() != Some(value.as_str()) {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
let model =
|
||||
if let Some(i) = s.task.config.iter().position(|o| o.category.as_deref() == Some("model")) {
|
||||
&mut s.task.config[i]
|
||||
} else {
|
||||
s.task.config.push(target.clone());
|
||||
s.task.config.last_mut().unwrap()
|
||||
};
|
||||
if !model.values.iter().any(|v| v.value == value) {
|
||||
model.values.push(candidate);
|
||||
}
|
||||
model.current = Some(value.clone());
|
||||
s.task.model = Some(value.clone());
|
||||
sync_usage_context_size(&mut s.task);
|
||||
false
|
||||
}
|
||||
refused => {
|
||||
if s.session_id.is_none()
|
||||
|| live.as_ref().is_some_and(|l| !l.resumable)
|
||||
|| self.start_fresh.load(Ordering::Acquire)
|
||||
{
|
||||
return Err(IdeError::unavailable(
|
||||
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
|
||||
));
|
||||
}
|
||||
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
|
||||
return Err(IdeError::invalid("wait until the agent is done"));
|
||||
}
|
||||
true
|
||||
}
|
||||
};
|
||||
s.wanted.retain(|c| c.id != target.id);
|
||||
s.pending_model = pending.then(|| target.id.clone());
|
||||
s.wanted.push(AgentConfigChoice { id: target.id, value });
|
||||
(!pending).then(|| {
|
||||
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
|
||||
(s.task.config.clone(), model)
|
||||
})
|
||||
};
|
||||
if let Some((config, model)) = accepted {
|
||||
self.shared.remember(&provider, Some(&config), None, model.as_deref());
|
||||
} else {
|
||||
self.recycle_resumable_session();
|
||||
}
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
|
||||
/// finished tasks don't keep an agent (and what it started) running. Only an agent that
|
||||
/// reloads its session: the next message starts it again with the conversation intact.
|
||||
@@ -2497,14 +2185,7 @@ impl Task {
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
let shell = std::mem::take(&mut self.state.lock().shell_context);
|
||||
let with_shell = |mut content: Vec<Value>| {
|
||||
if !shell.is_empty() {
|
||||
content.insert(0, json!({ "type": "text", "text": shell.join("\n") }));
|
||||
}
|
||||
content
|
||||
};
|
||||
let mut content = with_shell(self.content(&live, prompt).await);
|
||||
let mut content = self.content(&live, prompt).await;
|
||||
let mut result: Result<Value, RpcError> =
|
||||
live.peer.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
if live.driver == provider::Driver::Copilot
|
||||
@@ -2526,7 +2207,7 @@ impl Task {
|
||||
if !prompt.images.is_empty() && !live.capabilities.images {
|
||||
return Err(Failure::from("This agent can't read images.".to_owned()));
|
||||
}
|
||||
content = with_shell(self.content(&live, prompt).await);
|
||||
content = self.content(&live, prompt).await;
|
||||
result = live
|
||||
.peer
|
||||
.request("session/prompt", json!({ "sessionId": live.session, "prompt": content }), None)
|
||||
@@ -2607,12 +2288,10 @@ impl Task {
|
||||
{
|
||||
return Ok(live);
|
||||
}
|
||||
let (provider_id, cwd, saved, pending) = {
|
||||
let (provider_id, cwd, saved) = {
|
||||
let s = self.state.lock();
|
||||
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
|
||||
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
|
||||
};
|
||||
let pending_model = pending.as_ref().map(|(choice, _)| choice);
|
||||
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
|
||||
let can_fallback =
|
||||
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
|
||||
@@ -2621,8 +2300,8 @@ impl Task {
|
||||
} else {
|
||||
raw_spec.clone()
|
||||
};
|
||||
let opened = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone(), pending_model).await {
|
||||
Ok(live) => Ok(live),
|
||||
let live = match self.open_session(&provider_id, primary_spec, &cwd, saved.clone()).await {
|
||||
Ok(live) => live,
|
||||
Err(err) if can_fallback && err.allow_acp_fallback => {
|
||||
tracing::warn!(
|
||||
"agent task {}: Copilot headless session setup failed ({}); falling back to `copilot --acp`",
|
||||
@@ -2631,32 +2310,9 @@ impl Task {
|
||||
);
|
||||
self.shared.mark_copilot_acp_fallback(&raw_spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&raw_spec);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved, pending_model).await
|
||||
}
|
||||
Err(err) => Err(err),
|
||||
};
|
||||
let live = match opened {
|
||||
Ok(live) => live,
|
||||
Err(err) => {
|
||||
if let Some((choice, previous)) = pending {
|
||||
let mut s = self.state.lock();
|
||||
if s.pending_model() == Some(&choice) {
|
||||
s.pending_model = None;
|
||||
s.wanted.retain(|c| c.id != choice.id);
|
||||
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
|
||||
model.current.clone_from(&previous);
|
||||
}
|
||||
s.task.model.clone_from(&previous);
|
||||
if let Some(value) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: choice.id, value });
|
||||
}
|
||||
drop(s);
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
return Err(err.message);
|
||||
self.open_session(&provider_id, acp_spec, &cwd, saved).await.map_err(|e| e.message)?
|
||||
}
|
||||
Err(err) => return Err(err.message),
|
||||
};
|
||||
*self.live.lock() = Some(live.clone());
|
||||
Ok(live)
|
||||
@@ -2668,7 +2324,6 @@ impl Task {
|
||||
spec: provider::ProviderSpec,
|
||||
cwd: &Path,
|
||||
saved: Option<String>,
|
||||
pending_model: Option<&AgentConfigChoice>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
@@ -2718,12 +2373,6 @@ impl Task {
|
||||
let mut tried_auth = false;
|
||||
let mut session = None;
|
||||
let start_fresh = self.start_fresh.load(Ordering::Acquire);
|
||||
if pending_model.is_some() && (saved.is_none() || !can_load || start_fresh) {
|
||||
return Err(SessionOpenError {
|
||||
message: "The agent does not support resuming this session.".into(),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let (Some(id), true, false) = (saved, can_load, start_fresh) {
|
||||
self.replaying.store(true, Ordering::Release);
|
||||
let mut params = session_params(&cwd_s, &mcp_servers);
|
||||
@@ -2739,16 +2388,6 @@ impl Task {
|
||||
if let Some(message) = self.sign_in_error(&e, Some(&sign_in_message)) {
|
||||
return Err(SessionOpenError { message, allow_acp_fallback: false });
|
||||
}
|
||||
if pending_model.is_some() {
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
"Couldn't reopen this conversation's {} session: {}",
|
||||
spec.name,
|
||||
self.describe(e)
|
||||
),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
self.start_fresh.store(true, Ordering::Release);
|
||||
return Err(SessionOpenError {
|
||||
message: format!(
|
||||
@@ -2820,19 +2459,6 @@ impl Task {
|
||||
});
|
||||
let mut model_options = known;
|
||||
for choice in &wanted {
|
||||
let pending = pending_model == Some(choice);
|
||||
if pending
|
||||
&& !options.iter().any(|o| {
|
||||
o.id == choice.id
|
||||
&& (o.values.iter().any(|v| v.value == choice.value)
|
||||
|| (known && o.current.as_deref() == Some(choice.value.as_str())))
|
||||
})
|
||||
{
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session does not offer model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
|
||||
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
|
||||
if o.id == config::CURSOR_APPROVAL {
|
||||
@@ -2853,12 +2479,6 @@ impl Task {
|
||||
params["sessionId"] = json!(session_id);
|
||||
match peer.request::<_, Value>(method, params, None).await {
|
||||
Ok(reply) => {
|
||||
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
|
||||
return Err(SessionOpenError {
|
||||
message: format!("The reloaded session did not switch to model {}.", choice.value),
|
||||
allow_acp_fallback: false,
|
||||
});
|
||||
}
|
||||
if let Some(fresh) = reply.get("configOptions") {
|
||||
config::merge_update(&mut options, fresh);
|
||||
model_options = true;
|
||||
@@ -2872,9 +2492,6 @@ impl Task {
|
||||
o.current = Some(choice.value.clone());
|
||||
}
|
||||
}
|
||||
Err(e) if pending => {
|
||||
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
|
||||
}
|
||||
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
|
||||
}
|
||||
}
|
||||
@@ -2884,7 +2501,6 @@ impl Task {
|
||||
let mut s = self.state.lock();
|
||||
s.task.model = model_of(&options).or(s.task.model.take());
|
||||
s.task.config = options;
|
||||
s.pending_model = None;
|
||||
s.task.capabilities = capabilities;
|
||||
s.session_id = Some(session_id.clone());
|
||||
self.start_fresh.store(false, Ordering::Release);
|
||||
@@ -3782,14 +3398,21 @@ mod tests;
|
||||
/// The name agents know the built-in server by (its tools are `mcp__OpenIDEA__…` in Claude Code).
|
||||
const BUILTIN_SERVER: &str = "OpenIDEA";
|
||||
|
||||
// The desktop advertises its relay only while the built-in server is listening.
|
||||
static MCP_EXECUTABLE: parking_lot::RwLock<Option<std::path::PathBuf>> = parking_lot::RwLock::new(None);
|
||||
|
||||
pub fn set_mcp_executable(executable: Option<std::path::PathBuf>) {
|
||||
*MCP_EXECUTABLE.write() = executable;
|
||||
}
|
||||
|
||||
fn mcp_servers_for(supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
stdio_mcp_servers(MCP_EXECUTABLE.read().as_deref(), supported, root)
|
||||
}
|
||||
|
||||
fn stdio_mcp_servers(executable: Option<&std::path::Path>, supported: bool, root: &std::path::Path) -> Vec<Value> {
|
||||
let Some(executable) = executable.filter(|_| supported) else { return Vec::new() };
|
||||
let command = ide_mcp::stdio_command(executable, root);
|
||||
let env: Vec<Value> = ["OPENIDEA_SERVER_HOME", "OPENIDEA_DATA_DIR"]
|
||||
.into_iter()
|
||||
.filter_map(|name| std::env::var(name).ok().map(|value| json!({ "name": name, "value": value })))
|
||||
.collect();
|
||||
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": env })]
|
||||
vec![json!({ "name": BUILTIN_SERVER, "command": command[0], "args": command[1..], "env": [] })]
|
||||
}
|
||||
|
||||
/// What was sent of a streaming message: its first `bytes` (`utf16` UTF-16 units), which
|
||||
|
||||
@@ -399,429 +399,163 @@ pub fn apply_save_json(
|
||||
Ok(saved_names)
|
||||
}
|
||||
|
||||
const COPILOT_PLUGIN_MANIFESTS: &[&str] = &[
|
||||
".github/plugin/plugin.json",
|
||||
".plugin/plugin.json",
|
||||
".claude-plugin/plugin.json",
|
||||
".cursor-plugin/plugin.json",
|
||||
"plugin.json",
|
||||
];
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum SourceFormat {
|
||||
Jsonc,
|
||||
CodexToml,
|
||||
CopilotPlugin { root: PathBuf },
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct SourceSpec {
|
||||
id: String,
|
||||
label: String,
|
||||
id: &'static str,
|
||||
label: &'static str,
|
||||
path: PathBuf,
|
||||
format: SourceFormat,
|
||||
suggested_scope: McpScope,
|
||||
native_provider: Option<&'static str>,
|
||||
claude_project_lookup: bool,
|
||||
disabled_servers: std::sync::Arc<BTreeSet<String>>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct CopilotSettings {
|
||||
disabled_mcp_servers: std::sync::Arc<BTreeSet<String>>,
|
||||
disabled_plugins: BTreeSet<String>,
|
||||
}
|
||||
|
||||
fn external_source_specs(home_dir: Option<&Path>, workspace_root: Option<&Path>) -> Vec<SourceSpec> {
|
||||
let mut specs = Vec::new();
|
||||
let no_disabled: std::sync::Arc<BTreeSet<String>> = std::sync::Arc::new(BTreeSet::new());
|
||||
if let Some(root) = workspace_root {
|
||||
specs.push(SourceSpec {
|
||||
id: "workspace-mcp".into(),
|
||||
label: "Project (.mcp.json)".into(),
|
||||
id: "workspace-mcp",
|
||||
label: "Project (.mcp.json)",
|
||||
path: root.join(".mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "vscode-mcp".into(),
|
||||
label: "VS Code (.vscode/mcp.json)".into(),
|
||||
id: "vscode-mcp",
|
||||
label: "VS Code (.vscode/mcp.json)",
|
||||
path: root.join(".vscode").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor-project".into(),
|
||||
label: "Cursor Project (.cursor/mcp.json)".into(),
|
||||
id: "cursor-project",
|
||||
label: "Cursor Project (.cursor/mcp.json)",
|
||||
path: root.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex-project".into(),
|
||||
label: "Codex Project (.codex/config.toml)".into(),
|
||||
id: "codex-project",
|
||||
label: "Codex Project (.codex/config.toml)",
|
||||
path: root.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini-project".into(),
|
||||
label: "Gemini Project (.gemini/settings.json)".into(),
|
||||
id: "gemini-project",
|
||||
label: "Gemini Project (.gemini/settings.json)",
|
||||
path: root.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::Workspace,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
}
|
||||
if let Some(home) = home_dir {
|
||||
let copilot_dir = home.join(".copilot");
|
||||
let copilot_settings = read_copilot_settings(&copilot_dir);
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-cli".into(),
|
||||
label: "GitHub Copilot CLI".into(),
|
||||
path: copilot_dir.join("mcp-config.json"),
|
||||
id: "copilot-cli",
|
||||
label: "GitHub Copilot CLI",
|
||||
path: home.join(".copilot").join("mcp-config.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("copilot"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: copilot_settings.disabled_mcp_servers.clone(),
|
||||
});
|
||||
specs.extend(copilot_plugin_source_specs(&copilot_dir, &copilot_settings));
|
||||
specs.push(SourceSpec {
|
||||
id: "claude-code".into(),
|
||||
label: "Claude Code".into(),
|
||||
id: "claude-code",
|
||||
label: "Claude Code",
|
||||
path: home.join(".claude.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("claude"),
|
||||
claude_project_lookup: true,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "codex".into(),
|
||||
label: "Codex".into(),
|
||||
id: "codex",
|
||||
label: "Codex",
|
||||
path: home.join(".codex").join("config.toml"),
|
||||
format: SourceFormat::CodexToml,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("codex"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "cursor".into(),
|
||||
label: "Cursor".into(),
|
||||
id: "cursor",
|
||||
label: "Cursor",
|
||||
path: home.join(".cursor").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("cursor"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "gemini".into(),
|
||||
label: "Gemini CLI".into(),
|
||||
id: "gemini",
|
||||
label: "Gemini CLI",
|
||||
path: home.join(".gemini").join("settings.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("gemini"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "jetbrains-air".into(),
|
||||
label: "JetBrains Air".into(),
|
||||
id: "jetbrains-air",
|
||||
label: "JetBrains Air",
|
||||
path: home.join(".jetbrains").join("mcp").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled.clone(),
|
||||
});
|
||||
specs.push(SourceSpec {
|
||||
id: "copilot-intellij".into(),
|
||||
label: "GitHub Copilot (JetBrains)".into(),
|
||||
id: "copilot-intellij",
|
||||
label: "GitHub Copilot (JetBrains)",
|
||||
path: home.join(".config").join("github-copilot").join("intellij").join("mcp.json"),
|
||||
format: SourceFormat::Jsonc,
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: None,
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: no_disabled,
|
||||
});
|
||||
}
|
||||
specs
|
||||
}
|
||||
|
||||
fn read_copilot_settings(copilot_dir: &Path) -> CopilotSettings {
|
||||
let Ok(text) = std::fs::read_to_string(copilot_dir.join("settings.json")) else {
|
||||
return CopilotSettings::default();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return CopilotSettings::default();
|
||||
};
|
||||
let disabled_mcp_servers = root
|
||||
.get("disabledMcpServers")
|
||||
.and_then(Value::as_array)
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|v| v.as_str().map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned))
|
||||
.collect::<BTreeSet<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let disabled_plugins = root
|
||||
.get("enabledPlugins")
|
||||
.and_then(Value::as_object)
|
||||
.map(|obj| {
|
||||
obj.iter()
|
||||
.filter(|(_, v)| v.as_bool() == Some(false))
|
||||
.map(|(k, _)| k.trim().to_owned())
|
||||
.filter(|k| !k.is_empty())
|
||||
.collect::<BTreeSet<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
CopilotSettings { disabled_mcp_servers: std::sync::Arc::new(disabled_mcp_servers), disabled_plugins }
|
||||
}
|
||||
|
||||
fn copilot_plugin_source_specs(copilot_dir: &Path, settings: &CopilotSettings) -> Vec<SourceSpec> {
|
||||
let Ok(text) = std::fs::read_to_string(copilot_dir.join("config.json")) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let Some(installed) = root.get("installedPlugins").and_then(Value::as_array) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let mut seen_ids = HashSet::new();
|
||||
let mut specs = Vec::new();
|
||||
for entry in installed {
|
||||
let Some(obj) = entry.as_object() else { continue };
|
||||
if obj.get("enabled").and_then(Value::as_bool) == Some(false) {
|
||||
continue;
|
||||
}
|
||||
let Some(name) = obj.get("name").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
|
||||
continue;
|
||||
};
|
||||
let marketplace = obj.get("marketplace").and_then(Value::as_str).map(str::trim).unwrap_or_default();
|
||||
if settings.disabled_plugins.contains(name)
|
||||
|| (!marketplace.is_empty()
|
||||
&& (settings.disabled_plugins.contains(&format!("{name}@{marketplace}"))
|
||||
|| settings.disabled_plugins.contains(&format!("{marketplace}/{name}"))))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let Some(raw_cache) = obj.get("cache_path").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let plugin_root =
|
||||
if Path::new(raw_cache).is_relative() { copilot_dir.join(raw_cache) } else { PathBuf::from(raw_cache) };
|
||||
if !plugin_root.is_dir() {
|
||||
continue;
|
||||
}
|
||||
let Some((manifest_path, _)) = read_copilot_plugin_servers(&plugin_root) else {
|
||||
continue;
|
||||
};
|
||||
let base_id = if marketplace.is_empty() {
|
||||
format!("copilot-plugin:{name}")
|
||||
} else {
|
||||
format!("copilot-plugin:{marketplace}/{name}")
|
||||
};
|
||||
let mut id = base_id.clone();
|
||||
let mut suffix = 2usize;
|
||||
while !seen_ids.insert(id.clone()) {
|
||||
id = format!("{base_id}#{suffix}");
|
||||
suffix += 1;
|
||||
}
|
||||
let label = if marketplace.is_empty() {
|
||||
format!("GitHub Copilot Plugin ({name})")
|
||||
} else {
|
||||
format!("GitHub Copilot Plugin ({name} · {marketplace})")
|
||||
};
|
||||
specs.push(SourceSpec {
|
||||
id,
|
||||
label,
|
||||
path: manifest_path,
|
||||
format: SourceFormat::CopilotPlugin { root: plugin_root },
|
||||
suggested_scope: McpScope::User,
|
||||
native_provider: Some("copilot"),
|
||||
claude_project_lookup: false,
|
||||
disabled_servers: settings.disabled_mcp_servers.clone(),
|
||||
});
|
||||
}
|
||||
specs
|
||||
}
|
||||
|
||||
fn resolve_within_dir(base_dir: &Path, candidate: &Path) -> Option<PathBuf> {
|
||||
if candidate.as_os_str().is_empty() {
|
||||
return None;
|
||||
}
|
||||
let base_canon = dunce::canonicalize(base_dir).ok()?;
|
||||
let clean = candidate.strip_prefix(".").unwrap_or(candidate);
|
||||
let joined = if clean.is_relative() { base_dir.join(clean) } else { clean.to_path_buf() };
|
||||
let meta = std::fs::metadata(&joined).ok()?;
|
||||
if !meta.is_file() {
|
||||
return None;
|
||||
}
|
||||
let target_canon = dunce::canonicalize(&joined).ok()?;
|
||||
target_canon.starts_with(&base_canon).then_some(joined)
|
||||
}
|
||||
|
||||
fn expand_plugin_root_vars(value: &str, root: &str) -> String {
|
||||
value.replace("${COPILOT_PLUGIN_ROOT}", root).replace("${CLAUDE_PLUGIN_ROOT}", root).replace("${PLUGIN_ROOT}", root)
|
||||
}
|
||||
|
||||
fn expand_plugin_servers(servers: &mut BTreeMap<String, AgentMcpServer>, plugin_root: &Path) {
|
||||
let root = plugin_root.to_string_lossy();
|
||||
for srv in servers.values_mut() {
|
||||
if let Some(cmd) = srv.command.as_mut() {
|
||||
*cmd = expand_plugin_root_vars(cmd, &root);
|
||||
}
|
||||
for arg in &mut srv.args {
|
||||
*arg = expand_plugin_root_vars(arg, &root);
|
||||
}
|
||||
if let Some(url) = srv.url.as_mut() {
|
||||
*url = expand_plugin_root_vars(url, &root);
|
||||
}
|
||||
for val in srv.env.values_mut() {
|
||||
*val = expand_plugin_root_vars(val, &root);
|
||||
}
|
||||
for val in srv.headers.values_mut() {
|
||||
*val = expand_plugin_root_vars(val, &root);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_plugin_manifest_servers(
|
||||
plugin_root: &Path,
|
||||
manifest_path: &Path,
|
||||
mcp_val: &Value,
|
||||
) -> (PathBuf, BTreeMap<String, AgentMcpServer>) {
|
||||
match mcp_val {
|
||||
Value::String(rel) => {
|
||||
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
|
||||
let map = read_external_file(&path);
|
||||
return (path, map);
|
||||
}
|
||||
(manifest_path.to_path_buf(), BTreeMap::new())
|
||||
}
|
||||
Value::Object(_) => {
|
||||
let wrapper = json!({ "mcpServers": mcp_val });
|
||||
(manifest_path.to_path_buf(), extract_servers_from_root(&wrapper, None))
|
||||
}
|
||||
Value::Array(items) => {
|
||||
let mut merged = BTreeMap::new();
|
||||
let mut first_path: Option<PathBuf> = None;
|
||||
for item in items {
|
||||
match item {
|
||||
Value::String(rel) => {
|
||||
if let Some(path) = resolve_within_dir(plugin_root, Path::new(rel.trim())) {
|
||||
let map = read_external_file(&path);
|
||||
if !map.is_empty() && first_path.is_none() {
|
||||
first_path = Some(path);
|
||||
}
|
||||
merged.extend(map);
|
||||
}
|
||||
}
|
||||
Value::Object(_) => {
|
||||
let map = extract_servers_from_root(item, None);
|
||||
if !map.is_empty() && first_path.is_none() {
|
||||
first_path = Some(manifest_path.to_path_buf());
|
||||
}
|
||||
merged.extend(map);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
(first_path.unwrap_or_else(|| manifest_path.to_path_buf()), merged)
|
||||
}
|
||||
_ => (manifest_path.to_path_buf(), BTreeMap::new()),
|
||||
}
|
||||
}
|
||||
|
||||
fn read_copilot_plugin_servers(plugin_root: &Path) -> Option<(PathBuf, BTreeMap<String, AgentMcpServer>)> {
|
||||
if let Some(dot_mcp) = resolve_within_dir(plugin_root, Path::new(".mcp.json")) {
|
||||
let mut servers = read_external_file(&dot_mcp);
|
||||
if !servers.is_empty() {
|
||||
expand_plugin_servers(&mut servers, plugin_root);
|
||||
return Some((dot_mcp, servers));
|
||||
}
|
||||
}
|
||||
for rel in COPILOT_PLUGIN_MANIFESTS {
|
||||
let Some(manifest_path) = resolve_within_dir(plugin_root, Path::new(rel)) else {
|
||||
continue;
|
||||
};
|
||||
let Ok(text) = std::fs::read_to_string(&manifest_path) else {
|
||||
continue;
|
||||
};
|
||||
let Ok(manifest) = parse_jsonc_value(&text) else {
|
||||
continue;
|
||||
};
|
||||
let Some(mcp_val) = manifest.get("mcpServers") else {
|
||||
continue;
|
||||
};
|
||||
let (source_path, mut servers) = extract_plugin_manifest_servers(plugin_root, &manifest_path, mcp_val);
|
||||
if !servers.is_empty() {
|
||||
expand_plugin_servers(&mut servers, plugin_root);
|
||||
return Some((source_path, servers));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn read_source_servers(spec: &SourceSpec, workspace_root: Option<&Path>) -> BTreeMap<String, AgentMcpServer> {
|
||||
let mut servers = match &spec.format {
|
||||
SourceFormat::CopilotPlugin { root } => {
|
||||
read_copilot_plugin_servers(root).map(|(_, map)| map).unwrap_or_default()
|
||||
}
|
||||
SourceFormat::CodexToml => {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
parse_codex_toml_servers(&text)
|
||||
}
|
||||
SourceFormat::Jsonc => {
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut map = extract_servers_from_root(&root, None);
|
||||
if spec.claude_project_lookup
|
||||
&& let Some(ws) = workspace_root
|
||||
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
|
||||
{
|
||||
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
|
||||
for (proj_key, proj_val) in projects {
|
||||
let matches =
|
||||
Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
|
||||
if matches {
|
||||
for (name, srv) in extract_servers_from_root(proj_val, None) {
|
||||
map.insert(name, srv);
|
||||
}
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(&spec.path) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
if spec.format == SourceFormat::CodexToml {
|
||||
return parse_codex_toml_servers(&text);
|
||||
}
|
||||
let Ok(root) = parse_jsonc_value(&text) else {
|
||||
return BTreeMap::new();
|
||||
};
|
||||
let mut servers = extract_servers_from_root(&root, None);
|
||||
if spec.claude_project_lookup
|
||||
&& let Some(ws) = workspace_root
|
||||
&& let Some(projects) = root.get("projects").and_then(Value::as_object)
|
||||
{
|
||||
let ws_canon = dunce::canonicalize(ws).unwrap_or_else(|_| ws.to_path_buf());
|
||||
for (proj_key, proj_val) in projects {
|
||||
let matches = Path::new(proj_key) == ws || dunce::canonicalize(proj_key).is_ok_and(|c| c == ws_canon);
|
||||
if matches {
|
||||
for (name, srv) in extract_servers_from_root(proj_val, None) {
|
||||
servers.insert(name, srv);
|
||||
}
|
||||
}
|
||||
map
|
||||
}
|
||||
};
|
||||
for name in spec.disabled_servers.iter() {
|
||||
if let Some(srv) = servers.get_mut(name) {
|
||||
srv.enabled = false;
|
||||
}
|
||||
}
|
||||
servers
|
||||
@@ -878,8 +612,8 @@ pub fn discover_external_sources(home_dir: Option<&Path>, workspace_root: Option
|
||||
})
|
||||
.collect();
|
||||
out.push(McpExternalSource {
|
||||
id: spec.id,
|
||||
label: spec.label,
|
||||
id: spec.id.to_owned(),
|
||||
label: spec.label.to_owned(),
|
||||
path: IpcPath(spec.path),
|
||||
suggested_scope: spec.suggested_scope,
|
||||
native_provider: spec.native_provider.map(str::to_owned),
|
||||
@@ -907,7 +641,7 @@ pub fn apply_import_selected(
|
||||
let mut by_source: BTreeMap<&str, BTreeMap<String, AgentMcpServer>> = BTreeMap::new();
|
||||
for spec in &specs {
|
||||
if selections.iter().any(|s| s.source_id == spec.id) {
|
||||
by_source.insert(spec.id.as_str(), read_source_servers(spec, workspace_root));
|
||||
by_source.insert(spec.id, read_source_servers(spec, workspace_root));
|
||||
}
|
||||
}
|
||||
let target = match scope {
|
||||
@@ -1636,125 +1370,4 @@ mod tests {
|
||||
assert_eq!(workspace["events-sse"].transport, McpTransport::Sse);
|
||||
assert_eq!(workspace["events-sse"].url.as_deref(), Some("https://sse.example.com/events"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discovers_and_imports_copilot_installed_plugin_mcp_servers() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let home = tmp.path().join("home");
|
||||
let copilot = home.join(".copilot");
|
||||
let azure_root = copilot.join("installed-plugins/_direct/azure-skills");
|
||||
let inline_root = copilot.join("installed-plugins/awesome-copilot/inline-tools");
|
||||
let disabled_root = copilot.join("installed-plugins/_direct/disabled-plug");
|
||||
let outside_root = tmp.path().join("outside");
|
||||
|
||||
std::fs::create_dir_all(azure_root.join(".plugin")).unwrap();
|
||||
std::fs::create_dir_all(inline_root.join(".claude-plugin")).unwrap();
|
||||
std::fs::create_dir_all(&disabled_root).unwrap();
|
||||
std::fs::create_dir_all(&outside_root).unwrap();
|
||||
|
||||
std::fs::write(
|
||||
azure_root.join(".plugin/plugin.json"),
|
||||
r#"{"name":"azure","version":"1.2.106","mcpServers":"./.mcp.json"}"#,
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(
|
||||
azure_root.join(".mcp.json"),
|
||||
r#"{"mcpServers":{"azure":{"command":"npx","args":["-y","@azure/mcp@latest","${COPILOT_PLUGIN_ROOT}/cfg"],"env":{"PLUG_DIR":"${CLAUDE_PLUGIN_ROOT}"}}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(
|
||||
inline_root.join(".claude-plugin/plugin.json"),
|
||||
r#"{"name":"inline-tools","version":"0.1.0","mcpServers":{"inline-srv":{"command":"${PLUGIN_ROOT}/bin/run","args":["--stdio"]},"muted-srv":{"command":"echo","args":["off"]}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(
|
||||
disabled_root.join(".mcp.json"),
|
||||
r#"{"mcpServers":{"never":{"command":"npx","args":["never"]}}}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
std::fs::write(outside_root.join("secret.json"), r#"{"mcpServers":{"escaped":{"command":"sh"}}}"#).unwrap();
|
||||
let escape_root = copilot.join("installed-plugins/_direct/escape-plug");
|
||||
std::fs::create_dir_all(escape_root.join(".plugin")).unwrap();
|
||||
std::fs::write(
|
||||
escape_root.join(".plugin/plugin.json"),
|
||||
r#"{"name":"escape-plug","mcpServers":"../../../../outside/secret.json"}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// `~/.copilot/config.json` includes leading `//` comments in Copilot CLI.
|
||||
let config_json = format!(
|
||||
"// Managed automatically.\n{}",
|
||||
serde_json::json!({
|
||||
"installedPlugins": [
|
||||
{
|
||||
"name": "azure",
|
||||
"marketplace": "",
|
||||
"enabled": true,
|
||||
"cache_path": azure_root,
|
||||
},
|
||||
{
|
||||
"name": "inline-tools",
|
||||
"marketplace": "awesome-copilot",
|
||||
"enabled": true,
|
||||
"cache_path": inline_root,
|
||||
},
|
||||
{
|
||||
"name": "disabled-plug",
|
||||
"marketplace": "",
|
||||
"enabled": false,
|
||||
"cache_path": disabled_root,
|
||||
},
|
||||
{
|
||||
"name": "escape-plug",
|
||||
"marketplace": "",
|
||||
"enabled": true,
|
||||
"cache_path": escape_root,
|
||||
}
|
||||
]
|
||||
})
|
||||
);
|
||||
std::fs::write(copilot.join("config.json"), config_json).unwrap();
|
||||
std::fs::write(copilot.join("settings.json"), r#"{"disabledMcpServers":["muted-srv"]}"#).unwrap();
|
||||
|
||||
let sources = discover_external_sources(Some(&home), None);
|
||||
assert_eq!(sources.len(), 2);
|
||||
|
||||
let azure_src = sources.iter().find(|s| s.id == "copilot-plugin:azure").unwrap();
|
||||
assert_eq!(azure_src.label, "GitHub Copilot Plugin (azure)");
|
||||
assert_eq!(azure_src.native_provider.as_deref(), Some("copilot"));
|
||||
assert_eq!(azure_src.path.0, azure_root.join(".mcp.json"));
|
||||
assert_eq!(azure_src.servers.len(), 1);
|
||||
assert!(azure_src.servers[0].enabled);
|
||||
assert_eq!(
|
||||
azure_src.servers[0].args,
|
||||
vec!["-y", "@azure/mcp@latest", &format!("{}/cfg", azure_root.display())]
|
||||
);
|
||||
|
||||
let inline_src = sources.iter().find(|s| s.id == "copilot-plugin:awesome-copilot/inline-tools").unwrap();
|
||||
assert_eq!(inline_src.label, "GitHub Copilot Plugin (inline-tools · awesome-copilot)");
|
||||
assert_eq!(inline_src.path.0, inline_root.join(".claude-plugin/plugin.json"));
|
||||
let active = inline_src.servers.iter().find(|s| s.name == "inline-srv").unwrap();
|
||||
assert!(active.enabled);
|
||||
assert_eq!(active.command.as_deref(), Some(format!("{}/bin/run", inline_root.display()).as_str()));
|
||||
let muted = inline_src.servers.iter().find(|s| s.name == "muted-srv").unwrap();
|
||||
assert!(!muted.enabled);
|
||||
|
||||
let mut user = BTreeMap::new();
|
||||
let mut workspace = BTreeMap::new();
|
||||
let imported = apply_import_selected(
|
||||
&mut user,
|
||||
&mut workspace,
|
||||
Some(&home),
|
||||
None,
|
||||
McpScope::User,
|
||||
&[McpImportSelection { source_id: "copilot-plugin:azure".into(), name: "azure".into() }],
|
||||
false,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(imported, vec!["azure".to_string()]);
|
||||
assert_eq!(user["azure"].env.get("PLUG_DIR").map(String::as_str), Some(azure_root.to_str().unwrap()));
|
||||
}
|
||||
}
|
||||
@@ -672,8 +672,6 @@ pub enum AgentChangesView {
|
||||
SinceStart,
|
||||
/// The uncommitted files against `HEAD`; commits made since the start stay.
|
||||
Group,
|
||||
/// What the last turn changed, against the checkout as that turn started.
|
||||
LastTurn,
|
||||
}
|
||||
|
||||
/// A task's uncommitted files and the commits made since it started.
|
||||
|
||||
@@ -24,9 +24,7 @@ use std::process::Command;
|
||||
use std::time::Duration;
|
||||
|
||||
pub const REGISTRY_URL: &str = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
|
||||
const COPILOT_RELEASE_BASE: &str = "https://github.com/github/copilot-cli/releases/download";
|
||||
const MAX_REGISTRY_BYTES: u64 = 1024 * 1024;
|
||||
const MAX_CHECKSUM_BYTES: u64 = 64 * 1024;
|
||||
/// [`maintain`] refreshes a saved index older than this, so updates show without opening
|
||||
/// the registry.
|
||||
const REFRESH_AFTER: Duration = Duration::from_secs(24 * 60 * 60);
|
||||
@@ -144,9 +142,6 @@ struct Binary {
|
||||
env: BTreeMap<String, String>,
|
||||
#[serde(default)]
|
||||
sha256: Option<String>,
|
||||
/// Checksum manifest (`SHA256SUMS.txt`) naming `archive`'s filename when `sha256` is not inline.
|
||||
#[serde(skip)]
|
||||
sha256_url: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
@@ -177,48 +172,11 @@ fn parse(text: &str) -> IdeResult<Vec<Entry>> {
|
||||
if let Some(name) = provider::builtin_name(&e.id) {
|
||||
e.name = name.to_owned();
|
||||
}
|
||||
if e.id == "copilot" {
|
||||
add_copilot_release_binaries(&mut e, COPILOT_RELEASE_BASE);
|
||||
}
|
||||
e
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Upstream `github-copilot-cli` lists only an `npx` wrapper in the ACP Registry, while
|
||||
/// `github/copilot-cli` publishes standalone archives and `SHA256SUMS.txt` on every GitHub
|
||||
/// release. Supplying them installs Copilot without Node.js, npm, `~/.npmrc`, or mirror lag.
|
||||
fn add_copilot_release_binaries(entry: &mut Entry, release_base: &str) {
|
||||
let tag = format!("v{}", entry.version.trim_start_matches('v'));
|
||||
let base = format!("{}/{}", release_base.trim_end_matches('/'), tag);
|
||||
let sha256_url = format!("{base}/SHA256SUMS.txt");
|
||||
let (args, env) = match &entry.distribution.npx {
|
||||
Some(p) => (p.args.clone(), p.env.clone()),
|
||||
None => (vec!["--acp".into()], BTreeMap::new()),
|
||||
};
|
||||
let linux = if cfg!(target_env = "musl") { "linuxmusl" } else { "linux" };
|
||||
let linux_arm = format!("copilot-{linux}-arm64.tar.gz");
|
||||
let linux_x64 = format!("copilot-{linux}-x64.tar.gz");
|
||||
let targets = [
|
||||
("darwin-aarch64", "copilot-darwin-arm64.tar.gz", "./copilot"),
|
||||
("darwin-x86_64", "copilot-darwin-x64.tar.gz", "./copilot"),
|
||||
("linux-aarch64", linux_arm.as_str(), "./copilot"),
|
||||
("linux-x86_64", linux_x64.as_str(), "./copilot"),
|
||||
("windows-aarch64", "copilot-win32-arm64.zip", "copilot.exe"),
|
||||
("windows-x86_64", "copilot-win32-x64.zip", "copilot.exe"),
|
||||
];
|
||||
for (key, asset, cmd) in targets {
|
||||
entry.distribution.binary.entry(key.to_owned()).or_insert_with(|| Binary {
|
||||
archive: format!("{base}/{asset}"),
|
||||
cmd: cmd.to_owned(),
|
||||
args: args.clone(),
|
||||
env: env.clone(),
|
||||
sha256: None,
|
||||
sha256_url: Some(sha256_url.clone()),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn safe_segment(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& !s.starts_with('.')
|
||||
@@ -358,7 +316,7 @@ fn visible(
|
||||
None
|
||||
};
|
||||
let choice = choose(e, platform, on_path);
|
||||
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none() && b.sha256_url.is_none());
|
||||
let no_checksum = matches!(choice, Some(Choice::Binary(b)) if b.sha256.is_none());
|
||||
let distribution = choice.map(|c| c.kind());
|
||||
if distribution.is_none() && installed.is_none() {
|
||||
return None;
|
||||
@@ -465,20 +423,6 @@ fn install_entry(
|
||||
on_path: &dyn Fn(&str) -> bool,
|
||||
cancel: &CancellationToken,
|
||||
emit: Emit,
|
||||
) -> IdeResult<()> {
|
||||
install_entry_with(paths, entry, platform, on_path, &install_npm, cancel, emit)
|
||||
}
|
||||
|
||||
type NpmInstaller = dyn Fn(&Package, &Entry, &Path, Platform, &CancellationToken, Emit) -> IdeResult<PathBuf>;
|
||||
|
||||
fn install_entry_with(
|
||||
paths: &RegistryPaths,
|
||||
entry: &Entry,
|
||||
platform: Platform,
|
||||
on_path: &dyn Fn(&str) -> bool,
|
||||
npm_installer: &NpmInstaller,
|
||||
cancel: &CancellationToken,
|
||||
emit: Emit,
|
||||
) -> IdeResult<()> {
|
||||
if is_builtin(&entry.id) {
|
||||
return Err(IdeError::invalid(format!("{} is built in", entry.name)));
|
||||
@@ -499,32 +443,9 @@ fn install_entry_with(
|
||||
}
|
||||
fs::create_dir_all(&dir)?;
|
||||
let installed = match &choice {
|
||||
Choice::Binary(b) => match install_binary(b, &dir, cancel, emit) {
|
||||
Ok(exe) => Ok((exe, b.args.clone(), b.env.clone())),
|
||||
Err(e)
|
||||
if !cancel.is_cancelled()
|
||||
&& e.kind != ErrorKind::Cancelled
|
||||
&& !e.message.starts_with("checksum mismatch:")
|
||||
&& entry.distribution.npx.is_some()
|
||||
&& on_path("npm")
|
||||
&& on_path("node") =>
|
||||
{
|
||||
let p = entry.distribution.npx.as_ref().expect("checked");
|
||||
emit(InstallEvent::Line {
|
||||
text: format!("Binary download failed ({}); falling back to npm…", e.message),
|
||||
});
|
||||
fs::remove_dir_all(&dir)?;
|
||||
fs::create_dir_all(&dir)?;
|
||||
npm_installer(p, entry, &dir, platform, cancel, emit)
|
||||
.map(|exe| (exe, p.args.clone(), p.env.clone()))
|
||||
.map_err(|npm_err| {
|
||||
IdeError::new(npm_err.kind, format!("{}; npm fallback failed: {}", e.message, npm_err.message))
|
||||
})
|
||||
}
|
||||
Err(e) => Err(e),
|
||||
},
|
||||
Choice::Binary(b) => install_binary(b, &dir, cancel, emit).map(|exe| (exe, b.args.clone(), b.env.clone())),
|
||||
Choice::Npx(p) => {
|
||||
npm_installer(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
|
||||
install_npm(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
|
||||
}
|
||||
Choice::Uvx(p) => {
|
||||
install_uv(p, entry, &dir, platform, cancel, emit).map(|exe| (exe, p.args.clone(), p.env.clone()))
|
||||
@@ -587,23 +508,13 @@ fn install_binary(b: &Binary, dir: &Path, cancel: &CancellationToken, emit: Emit
|
||||
fs::create_dir_all(&downloads)?;
|
||||
let file = downloads.join(name);
|
||||
emit(InstallEvent::Line { text: format!("Downloading {}", b.archive) });
|
||||
let http = http()?;
|
||||
http.download(&b.archive, &file, None, cancel, emit)?;
|
||||
match (&b.sha256, &b.sha256_url) {
|
||||
(Some(expected), _) => {
|
||||
http()?.download(&b.archive, &file, None, cancel, emit)?;
|
||||
match &b.sha256 {
|
||||
Some(expected) => {
|
||||
verify_sha256(&file, expected)?;
|
||||
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
|
||||
}
|
||||
(None, Some(checksum_url)) => {
|
||||
check_url(checksum_url)?;
|
||||
let text = http.get_text_limited(checksum_url, Some(MAX_CHECKSUM_BYTES), cancel)?;
|
||||
let expected = ide_tools::sources::parse_checksum(&text, name).ok_or_else(|| {
|
||||
IdeError::new(ErrorKind::Protocol, format!("no SHA-256 checksum for {name} in {checksum_url}"))
|
||||
})?;
|
||||
verify_sha256(&file, &expected)?;
|
||||
emit(InstallEvent::Line { text: "SHA-256 checksum verified".into() });
|
||||
}
|
||||
(None, None) => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
|
||||
None => emit(InstallEvent::Line { text: "The registry gives no checksum for this download".into() }),
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
@@ -656,20 +567,6 @@ fn install_npm(
|
||||
platform: Platform,
|
||||
cancel: &CancellationToken,
|
||||
emit: Emit,
|
||||
) -> IdeResult<PathBuf> {
|
||||
let (name, _) = split_npm_spec(&p.package);
|
||||
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
|
||||
install_npm_with(&npm, p, entry, dir, platform, cancel, emit)
|
||||
}
|
||||
|
||||
fn install_npm_with(
|
||||
npm: &Path,
|
||||
p: &Package,
|
||||
entry: &Entry,
|
||||
dir: &Path,
|
||||
platform: Platform,
|
||||
cancel: &CancellationToken,
|
||||
emit: Emit,
|
||||
) -> IdeResult<PathBuf> {
|
||||
let (name, version) = split_npm_spec(&p.package);
|
||||
let spec = match version {
|
||||
@@ -677,27 +574,10 @@ fn install_npm_with(
|
||||
_ => format!("{name}@{}", entry.version),
|
||||
};
|
||||
check_spec(&spec)?;
|
||||
let specs = [spec.clone()];
|
||||
ide_tools::run_npm_with_public_fallback(
|
||||
|extra| {
|
||||
if !extra.is_empty() {
|
||||
let _ = fs::remove_dir_all(dir.join("node_modules"));
|
||||
}
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.arg("install")
|
||||
.arg("--prefix")
|
||||
.arg(dir)
|
||||
.args(["--no-audit", "--no-fund"])
|
||||
.args(extra)
|
||||
.arg(&spec)
|
||||
.current_dir(dir);
|
||||
cmd
|
||||
},
|
||||
&specs,
|
||||
false,
|
||||
cancel,
|
||||
emit,
|
||||
)?;
|
||||
let npm = which::which("npm").map_err(|_| IdeError::unavailable(format!("npm is required to install {name}")))?;
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.arg("install").arg("--prefix").arg(dir).args(["--no-audit", "--no-fund"]).arg(&spec).current_dir(dir);
|
||||
ide_tools::run_streamed(cmd, cancel, emit)?;
|
||||
let modules = dir.join("node_modules");
|
||||
let manifest: serde_json::Value = fs::read_to_string(modules.join(name).join("package.json"))
|
||||
.ok()
|
||||
@@ -992,58 +872,6 @@ mod tests {
|
||||
assert!(check_url("ftp://x/a").is_err());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn npm_registry_agent_retries_against_public_npmjs_on_mirror_miss() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let install_dir = dir.path().join("acme/1.2.0");
|
||||
fs::create_dir_all(&install_dir).unwrap();
|
||||
let log = dir.path().join("npm-calls.log");
|
||||
let npm = dir.path().join("npm");
|
||||
fs::write(
|
||||
&npm,
|
||||
format!(
|
||||
r#"#!/bin/sh
|
||||
echo "$@" >> '{}'
|
||||
case " $* " in
|
||||
*" --registry=https://registry.npmjs.org/ --@acme:registry=https://registry.npmjs.org/ "*)
|
||||
prefix=""; while [ $# -gt 0 ]; do [ "$1" = "--prefix" ] && prefix="$2"; shift; done
|
||||
mkdir -p "$prefix/node_modules/.bin" "$prefix/node_modules/@acme/agent-acp"
|
||||
printf '#!/bin/sh\necho 1.2.0\n' > "$prefix/node_modules/.bin/agent-acp"
|
||||
chmod +x "$prefix/node_modules/.bin/agent-acp"
|
||||
printf '{{"bin":"cli.js"}}\n' > "$prefix/node_modules/@acme/agent-acp/package.json"
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
echo "npm error code ETARGET" >&2
|
||||
echo "npm error notarget No matching version found for @acme/[email protected]." >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
"#,
|
||||
log.display()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
archive::make_executable(&npm).unwrap();
|
||||
|
||||
let index = r#"{"agents":[
|
||||
{"id":"acme","name":"Acme","version":"1.2.0",
|
||||
"distribution":{"npx":{"package":"@acme/[email protected]","args":["--acp"]}}}
|
||||
]}"#;
|
||||
let entry = parse(index).unwrap().remove(0);
|
||||
let pkg = entry.distribution.npx.as_ref().unwrap();
|
||||
let exe =
|
||||
install_npm_with(&npm, pkg, &entry, &install_dir, MAC_ARM, &CancellationToken::new(), &|_| {}).unwrap();
|
||||
let calls: Vec<String> = fs::read_to_string(&log).unwrap().lines().map(str::to_owned).collect();
|
||||
assert_eq!(calls.len(), 2, "{calls:?}");
|
||||
assert!(!calls[0].contains("--registry="), "{calls:?}");
|
||||
assert!(calls[1].contains("--registry=https://registry.npmjs.org/"), "{calls:?}");
|
||||
assert!(calls[1].contains("--@acme:registry=https://registry.npmjs.org/"), "{calls:?}");
|
||||
assert_eq!(exe, install_dir.join("node_modules/.bin/agent-acp"));
|
||||
assert!(exe.is_file());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn checksums_are_verified() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
@@ -1141,18 +969,11 @@ esac
|
||||
assert_eq!(entries.len(), 1);
|
||||
assert_eq!((entries[0].id.as_str(), entries[0].name.as_str()), ("copilot", "GitHub Copilot"));
|
||||
|
||||
// Copilot installs as a verified GitHub Release binary even without Node.js or npm.
|
||||
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
|
||||
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
|
||||
assert_eq!(shown.len(), 1);
|
||||
assert_eq!(
|
||||
(
|
||||
shown[0].id.as_str(),
|
||||
shown[0].name.as_str(),
|
||||
shown[0].installed.as_deref(),
|
||||
shown[0].distribution,
|
||||
shown[0].no_checksum,
|
||||
),
|
||||
("copilot", "GitHub Copilot", None, Some(RegistryDistribution::Binary), false)
|
||||
(shown[0].id.as_str(), shown[0].name.as_str(), shown[0].installed.as_deref()),
|
||||
("copilot", "GitHub Copilot", None)
|
||||
);
|
||||
|
||||
CustomAgent {
|
||||
@@ -1166,7 +987,7 @@ esac
|
||||
.write(&p.agent_file("copilot"))
|
||||
.unwrap();
|
||||
|
||||
let shown = visible(&p, &entries, MAC_ARM, &|_| false);
|
||||
let shown = visible(&p, &entries, MAC_ARM, &|c| c == "npm" || c == "node");
|
||||
assert_eq!((shown[0].installed.as_deref(), shown[0].update), (Some("1.0.104"), true));
|
||||
|
||||
write_atomic(&p.cache_file, index.as_bytes()).unwrap();
|
||||
@@ -1186,82 +1007,4 @@ esac
|
||||
let fallback = provider::load(Some(&p.agents_dir), None).into_iter().find(|s| s.id == "copilot").unwrap();
|
||||
assert_eq!(fallback.source, AgentSource::Builtin);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn installs_copilot_from_verified_release_archive_and_falls_back_to_npm_when_unavailable() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let p = paths(dir.path());
|
||||
let served = dir.path().join("releases/v1.0.114");
|
||||
fs::create_dir_all(&served).unwrap();
|
||||
let archive = served.join("copilot-darwin-arm64.tar.gz");
|
||||
let stage = dir.path().join("archive-stage");
|
||||
fs::create_dir_all(&stage).unwrap();
|
||||
let staged_exe = stage.join("copilot");
|
||||
fs::write(&staged_exe, "#!/bin/sh\necho 1.0.114\n").unwrap();
|
||||
archive::make_executable(&staged_exe).unwrap();
|
||||
assert!(
|
||||
Command::new("tar")
|
||||
.arg("-czf")
|
||||
.arg(&archive)
|
||||
.arg("-C")
|
||||
.arg(&stage)
|
||||
.arg("copilot")
|
||||
.status()
|
||||
.unwrap()
|
||||
.success()
|
||||
);
|
||||
let sha = ide_tools::sources::sha256_file(&archive).unwrap();
|
||||
let sums = served.join("SHA256SUMS.txt");
|
||||
fs::write(&sums, format!("{sha} copilot-darwin-arm64.tar.gz\n")).unwrap();
|
||||
|
||||
let index = r#"{"agents":[
|
||||
{"id":"github-copilot-cli","name":"Copilot","version":"1.0.114",
|
||||
"distribution":{"npx":{"package":"@github/[email protected]","args":["--acp"]}}}
|
||||
]}"#;
|
||||
let mut entry = parse(index).unwrap().remove(0);
|
||||
entry.distribution.binary.clear();
|
||||
add_copilot_release_binaries(&mut entry, &format!("file://{}", dir.path().join("releases").display()));
|
||||
|
||||
let fake_npm = |_: &Package, _: &Entry, dest: &Path, _: Platform, _: &CancellationToken, _: Emit| {
|
||||
let exe = dest.join("node_modules/.bin/copilot");
|
||||
fs::create_dir_all(exe.parent().unwrap())?;
|
||||
fs::write(&exe, "#!/bin/sh\necho npm-1.0.114\n")?;
|
||||
archive::make_executable(&exe)?;
|
||||
Ok(exe)
|
||||
};
|
||||
let node_on_path = |cmd: &str| matches!(cmd, "npm" | "node");
|
||||
|
||||
let cancel = CancellationToken::new();
|
||||
let lines = std::sync::Mutex::new(Vec::new());
|
||||
let emit = |e: InstallEvent| {
|
||||
if let InstallEvent::Line { text } = e {
|
||||
lines.lock().unwrap().push(text);
|
||||
}
|
||||
};
|
||||
|
||||
// 1. Verified GitHub Release archive installs directly without invoking npm.
|
||||
install_entry_with(&p, &entry, MAC_ARM, &|_| false, &fake_npm, &cancel, &emit).unwrap();
|
||||
assert!(lines.lock().unwrap().iter().any(|l| l == "SHA-256 checksum verified"));
|
||||
let installed_bin = p.tools_dir.join("copilot/1.0.114/copilot");
|
||||
assert!(installed_bin.is_file());
|
||||
let saved = CustomAgent::read(&p.agent_file("copilot")).unwrap();
|
||||
assert_eq!(saved.command, installed_bin.to_string_lossy());
|
||||
assert_eq!(saved.args, ["--acp"]);
|
||||
|
||||
// 2. A tampered binary fails checksum verification and never falls back to npm.
|
||||
fs::write(&sums, format!("{} copilot-darwin-arm64.tar.gz\n", "0".repeat(64))).unwrap();
|
||||
let err = install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap_err();
|
||||
assert!(err.message.contains("checksum mismatch"), "{err:?}");
|
||||
assert!(!p.tools_dir.join("copilot/1.0.114").exists());
|
||||
|
||||
// 3. When the release download itself is unreachable, npm fallback installs it.
|
||||
fs::remove_file(&archive).unwrap();
|
||||
lines.lock().unwrap().clear();
|
||||
install_entry_with(&p, &entry, MAC_ARM, &node_on_path, &fake_npm, &cancel, &emit).unwrap();
|
||||
assert!(lines.lock().unwrap().iter().any(|l| l.contains("falling back to npm")));
|
||||
let npm_bin = p.tools_dir.join("copilot/1.0.114/node_modules/.bin/copilot");
|
||||
assert!(npm_bin.is_file());
|
||||
assert_eq!(CustomAgent::read(&p.agent_file("copilot")).unwrap().command, npm_bin.to_string_lossy());
|
||||
}
|
||||
}
|
||||
@@ -1,160 +0,0 @@
|
||||
//! `!` commands from the composer: run in the task's folder with the user's shell, outside
|
||||
//! any turn, and handed to the agent with the next message as Claude Code's bash mode does.
|
||||
|
||||
use ide_core::CancellationToken;
|
||||
use std::path::Path;
|
||||
use std::process::Stdio;
|
||||
use tokio::io::AsyncReadExt;
|
||||
use tokio::process::Command;
|
||||
|
||||
/// Output kept from each stream; longer output keeps its tail.
|
||||
const MAX_STREAM: usize = 32 * 1024;
|
||||
|
||||
#[derive(Debug, Default, PartialEq)]
|
||||
pub(crate) struct Ran {
|
||||
/// The exit code; `None` when it didn't start, was stopped or ended by a signal.
|
||||
pub code: Option<i32>,
|
||||
pub stdout: String,
|
||||
pub stderr: String,
|
||||
/// Why it didn't finish: it couldn't start, or it was stopped.
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
impl Ran {
|
||||
/// What the conversation shows: the output, then how it ended unless it succeeded.
|
||||
pub fn shown(&self) -> String {
|
||||
let mut text = [self.stdout.trim_end(), self.stderr.trim_end()]
|
||||
.into_iter()
|
||||
.filter(|t| !t.is_empty())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let end = match (&self.error, self.code) {
|
||||
(Some(error), _) => Some(error.clone()),
|
||||
(None, Some(0)) => None,
|
||||
(None, Some(code)) => Some(format!("Exit code {code}")),
|
||||
(None, None) => Some("Terminated".into()),
|
||||
};
|
||||
if let Some(end) = end {
|
||||
if !text.is_empty() {
|
||||
text.push('\n');
|
||||
}
|
||||
text.push_str(&end);
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
/// The block that goes to the agent ahead of the next message.
|
||||
pub fn context(&self, command: &str) -> String {
|
||||
let mut stderr = self.stderr.trim_end().to_owned();
|
||||
if let Some(error) = &self.error {
|
||||
if !stderr.is_empty() {
|
||||
stderr.push('\n');
|
||||
}
|
||||
stderr.push_str(error);
|
||||
} else if let Some(code) = self.code.filter(|c| *c != 0) {
|
||||
if !stderr.is_empty() {
|
||||
stderr.push('\n');
|
||||
}
|
||||
stderr.push_str(&format!("Exit code {code}"));
|
||||
}
|
||||
format!(
|
||||
"<bash-input>{command}</bash-input>\n<bash-stdout>{}</bash-stdout><bash-stderr>{stderr}</bash-stderr>",
|
||||
self.stdout.trim_end()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `command` with the user's shell in `cwd` until it ends or `cancel` stops it.
|
||||
pub(crate) async fn run(command: &str, cwd: &Path, cancel: &CancellationToken) -> Ran {
|
||||
let mut cmd = shell(command);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.current_dir(cwd).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true);
|
||||
let mut child = match cmd.spawn() {
|
||||
Ok(child) => child,
|
||||
Err(e) => return Ran { error: Some(format!("Cannot run it: {e}")), ..Ran::default() },
|
||||
};
|
||||
let (Some(mut out), Some(mut err)) = (child.stdout.take(), child.stderr.take()) else {
|
||||
return Ran { error: Some("Cannot read its output".into()), ..Ran::default() };
|
||||
};
|
||||
let finished = async move {
|
||||
let (mut stdout, mut stderr) = (Vec::new(), Vec::new());
|
||||
let _ = tokio::join!(out.read_to_end(&mut stdout), err.read_to_end(&mut stderr));
|
||||
let code = child.wait().await.ok().and_then(|s| s.code());
|
||||
Ran { code, stdout: tail(&stdout), stderr: tail(&stderr), error: None }
|
||||
};
|
||||
tokio::select! {
|
||||
ran = finished => ran,
|
||||
// Dropping the child kills it.
|
||||
() = cancel.cancelled() => Ran { error: Some("Stopped".into()), ..Ran::default() },
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn shell(command: &str) -> Command {
|
||||
let shell = std::env::var("SHELL").ok().filter(|s| !s.trim().is_empty()).unwrap_or_else(|| "/bin/sh".into());
|
||||
let mut cmd = Command::new(shell);
|
||||
cmd.arg("-c").arg(command);
|
||||
cmd
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn shell(command: &str) -> Command {
|
||||
let mut cmd = Command::new(std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".into()));
|
||||
// `/S /C "…"` runs the line as typed: cmd strips only the outer quotes.
|
||||
cmd.raw_arg("/D /S /C \"").raw_arg(command).raw_arg("\"");
|
||||
cmd
|
||||
}
|
||||
|
||||
fn tail(bytes: &[u8]) -> String {
|
||||
let text = String::from_utf8_lossy(bytes);
|
||||
if text.len() <= MAX_STREAM {
|
||||
return text.into_owned();
|
||||
}
|
||||
let mut cut = text.len() - MAX_STREAM;
|
||||
while !text.is_char_boundary(cut) {
|
||||
cut += 1;
|
||||
}
|
||||
format!("…{}", &text[cut..])
|
||||
}
|
||||
|
||||
#[cfg(all(test, not(windows)))]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn runs_in_the_folder_and_reports_output_and_exit_code() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::write(dir.path().join("marker.txt"), "").unwrap();
|
||||
let ran = run("ls; echo oops >&2; exit 3", dir.path(), &CancellationToken::new()).await;
|
||||
assert_eq!(ran.code, Some(3));
|
||||
assert_eq!(ran.stdout.trim(), "marker.txt");
|
||||
assert_eq!(ran.stderr.trim(), "oops");
|
||||
assert_eq!(ran.shown(), "marker.txt\noops\nExit code 3");
|
||||
assert_eq!(
|
||||
ran.context("ls"),
|
||||
"<bash-input>ls</bash-input>\n<bash-stdout>marker.txt</bash-stdout><bash-stderr>oops\nExit code 3</bash-stderr>"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_stopped_command_is_killed() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let stop = cancel.clone();
|
||||
tokio::spawn(async move {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
|
||||
stop.cancel();
|
||||
});
|
||||
let started = std::time::Instant::now();
|
||||
let ran = run("sleep 30", dir.path(), &cancel).await;
|
||||
assert!(started.elapsed() < std::time::Duration::from_secs(5));
|
||||
assert_eq!(ran.shown(), "Stopped");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn long_output_keeps_its_tail() {
|
||||
let long = "x".repeat(MAX_STREAM + 10) + "end";
|
||||
let kept = tail(long.as_bytes());
|
||||
assert!(kept.starts_with('…') && kept.ends_with("end"));
|
||||
}
|
||||
}
|
||||
@@ -59,8 +59,6 @@ struct FakeAgent {
|
||||
session_steering: bool,
|
||||
/// Records the `mcpServers` array passed to `session/new`, `session/load`, and `session/fork`.
|
||||
mcp_calls: Mutex<Vec<(String, Vec<String>)>>,
|
||||
/// The content blocks of each `session/prompt`.
|
||||
prompts: Mutex<Vec<Value>>,
|
||||
}
|
||||
|
||||
impl FakeAgent {
|
||||
@@ -249,17 +247,7 @@ impl Handler for FakeAgent {
|
||||
Ok(json!({}))
|
||||
}
|
||||
"session/prompt" => {
|
||||
self.prompts.lock().push(params.get("prompt").cloned().unwrap_or(Value::Null));
|
||||
// `!` commands run since the last message come first; the message follows.
|
||||
let first = match params.pointer("/prompt/0/text").and_then(Value::as_str) {
|
||||
Some(t) if t.starts_with("<bash-input>") => 1,
|
||||
_ => 0,
|
||||
};
|
||||
let text = params
|
||||
.pointer(&format!("/prompt/{first}/text"))
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or_default()
|
||||
.to_owned();
|
||||
let text = params.pointer("/prompt/0/text").and_then(Value::as_str).unwrap_or_default().to_owned();
|
||||
if text.starts_with("<send_user_message_question_reply>") {
|
||||
self.say(&session, "answer received");
|
||||
return Ok(json!({"stopReason": "end_turn"}));
|
||||
@@ -1373,53 +1361,6 @@ async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let turns = agent.prompts.lock().len();
|
||||
|
||||
mgr.run_shell(&task.id, " echo shell-out ", ide_core::CancellationToken::new()).await.unwrap();
|
||||
assert_eq!(agent.prompts.lock().len(), turns, "a `!` command starts no turn");
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
let Some(AgentEntry::Tool { title, kind, status, output, .. }) = entries.last() else {
|
||||
panic!("no entry for the command: {entries:?}")
|
||||
};
|
||||
assert_eq!((title.as_str(), kind.as_str(), *status), ("! echo shell-out", "execute", AgentToolStatus::Completed));
|
||||
assert_eq!(output.as_deref(), Some("shell-out"));
|
||||
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let sent = agent.prompts.lock().last().cloned().unwrap();
|
||||
assert_eq!(
|
||||
sent.pointer("/0/text").and_then(Value::as_str),
|
||||
Some(
|
||||
"<bash-input>echo shell-out</bash-input>\n<bash-stdout>shell-out</bash-stdout><bash-stderr></bash-stderr>"
|
||||
)
|
||||
);
|
||||
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
|
||||
// Only once.
|
||||
mgr.prompt(&task.id, text("again"), false).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let sent = agent.prompts.lock().last().cloned().unwrap();
|
||||
assert_eq!(sent.pointer("/0/text").and_then(Value::as_str), Some("again"));
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2911,10 +2852,7 @@ async fn task_project_root_controls_local_and_worktree_repositories() {
|
||||
let changes = mgr.changes(&task.id).await.unwrap();
|
||||
assert_eq!(changes.len(), 1);
|
||||
assert_eq!(changes[0].path.0, task.cwd.0.join("file.txt"));
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, changes[0].path.0.clone(), AgentChangesView::SinceStart).await.unwrap().as_deref(),
|
||||
Some("original\n")
|
||||
);
|
||||
assert_eq!(mgr.base_text(&task.id, changes[0].path.0.clone()).await.unwrap().as_deref(), Some("original\n"));
|
||||
let saved = std::fs::read(root.join("store").join(format!("{}.json", task.id))).unwrap();
|
||||
assert!(String::from_utf8(saved).unwrap().contains("projectRoot"));
|
||||
let mut old = serde_json::to_value(&task).unwrap();
|
||||
@@ -3698,178 +3636,6 @@ async fn changed(mgr: &AgentManager, id: &str) -> Vec<String> {
|
||||
mgr.changes(id).await.unwrap().into_iter().map(|c| c.rel_path).collect()
|
||||
}
|
||||
|
||||
/// Waits until the turn asks for permission, runs `work` (what the agent does), then stops it.
|
||||
async fn one_turn(mgr: &AgentManager, id: &str, prompt: Option<&str>, work: impl FnOnce()) {
|
||||
if let Some(prompt) = prompt {
|
||||
mgr.prompt(id, text(prompt), false).await.unwrap();
|
||||
}
|
||||
wait_for(mgr, id, AgentStatus::NeedsInput).await;
|
||||
work();
|
||||
mgr.cancel(id, None).unwrap();
|
||||
wait_for(mgr, id, AgentStatus::Ready).await;
|
||||
}
|
||||
|
||||
async fn turn_changed(mgr: &AgentManager, id: &str) -> Vec<(String, ide_vcs::ChangeKind, u32, u32)> {
|
||||
let changes = mgr.turn_changes(id).await.unwrap();
|
||||
changes.into_iter().map(|c| (c.rel_path, c.kind, c.added, c.removed)).collect()
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn the_last_turn_lists_and_rolls_back_only_its_own_changes() {
|
||||
use ide_vcs::ChangeKind::{Added, Deleted, Modified};
|
||||
for isolation in [Isolation::Local, Isolation::Worktree] {
|
||||
for eol in EOLS {
|
||||
let repo = Checkout::new(eol);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.write("gone.txt", "base\n");
|
||||
repo.write("mine.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("Hello"),
|
||||
provider: "claude".into(),
|
||||
isolation,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let cwd = task.cwd.0.clone();
|
||||
let write = |rel: &str, text: &str| {
|
||||
let text = match eol {
|
||||
Eol::Lf => text.to_owned(),
|
||||
Eol::Crlf => text.replace('\n', "\r\n"),
|
||||
};
|
||||
std::fs::write(cwd.join(rel), text).unwrap();
|
||||
};
|
||||
let read = |rel: &str| std::fs::read_to_string(cwd.join(rel)).unwrap().replace("\r\n", "\n");
|
||||
let case = format!("{isolation:?} {eol:?}");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}: no turn has ended yet");
|
||||
|
||||
one_turn(&mgr, &task.id, None, || {
|
||||
write("a.txt", "base\nturn 1\n");
|
||||
write("one.txt", "one\n");
|
||||
})
|
||||
.await;
|
||||
// The user's own work between the turns belongs to neither.
|
||||
write("mine.txt", "base\nmine\n");
|
||||
one_turn(&mgr, &task.id, Some("more"), || {
|
||||
write("a.txt", "base\nturn 1\nturn 2\n");
|
||||
write("one.txt", "one\ntwo\n");
|
||||
write("two.txt", "two\n");
|
||||
std::fs::remove_file(cwd.join("gone.txt")).unwrap();
|
||||
})
|
||||
.await;
|
||||
// And after the turn.
|
||||
write("later.txt", "mine\n");
|
||||
|
||||
assert_eq!(
|
||||
turn_changed(&mgr, &task.id).await,
|
||||
[
|
||||
("a.txt".into(), Modified, 1, 0),
|
||||
("gone.txt".into(), Deleted, 0, 1),
|
||||
("one.txt".into(), Modified, 1, 0),
|
||||
("two.txt".into(), Added, 1, 0),
|
||||
],
|
||||
"{case}"
|
||||
);
|
||||
let turn_base = |rel: &str| {
|
||||
let path = cwd.join(rel);
|
||||
let mgr = &mgr;
|
||||
let id = task.id.clone();
|
||||
async move {
|
||||
let text = mgr.base_text(&id, path, AgentChangesView::LastTurn).await.unwrap();
|
||||
text.map(|t| t.replace("\r\n", "\n"))
|
||||
}
|
||||
};
|
||||
assert_eq!(turn_base("a.txt").await.as_deref(), Some("base\nturn 1\n"), "{case}");
|
||||
assert_eq!(turn_base("gone.txt").await.as_deref(), Some("base\n"), "{case}");
|
||||
assert_eq!(turn_base("two.txt").await, None, "{case}");
|
||||
let whole: Vec<String> = changed(&mgr, &task.id).await;
|
||||
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
|
||||
|
||||
// One file, then the rest, after a restart: from the copies saved as the turn started.
|
||||
mgr.rollback_changes(&task.id, Some(vec!["one.txt".into()]), AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(read("one.txt"), "one\n", "{case}");
|
||||
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 3, "{case}");
|
||||
mgr.shutdown();
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(read("a.txt"), "base\nturn 1\n", "{case}");
|
||||
assert_eq!(read("gone.txt"), "base\n", "{case}");
|
||||
assert!(!cwd.join("two.txt").exists(), "{case}");
|
||||
assert_eq!(read("mine.txt"), "base\nmine\n", "{case}: the user's edit between turns stays");
|
||||
assert_eq!(read("later.txt"), "mine\n", "{case}: and the one after");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty(), "{case}");
|
||||
// The task's own changes from its first turn stay.
|
||||
let whole: Vec<String> = changed(&mgr, &task.id).await;
|
||||
assert!(["a.txt", "one.txt"].iter().all(|f| whole.iter().any(|w| w == f)), "{case}: {whole:?}");
|
||||
|
||||
mgr.delete(&task.id, true).await.unwrap();
|
||||
assert!(!repo.dir.join("store").join(format!("{}.turn", task.id)).exists(), "{case}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rolling_back_the_whole_task_leaves_the_last_turn_nothing_to_list() {
|
||||
let repo = Checkout::new(Eol::Lf);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask { prompt: text("Hello"), provider: "claude".into(), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
one_turn(&mgr, &task.id, None, || repo.write("a.txt", "base\nturn 1\n")).await;
|
||||
one_turn(&mgr, &task.id, Some("more"), || repo.write("a.txt", "base\nturn 1\nturn 2\n")).await;
|
||||
assert_eq!(turn_changed(&mgr, &task.id).await.len(), 1);
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert_eq!(repo.read("a.txt"), "base\n");
|
||||
assert!(mgr.turn_changes(&task.id).await.unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_commit_made_in_the_last_turn_is_among_its_changes() {
|
||||
let repo = Checkout::new(Eol::Lf);
|
||||
repo.write("a.txt", "base\n");
|
||||
repo.commit("init");
|
||||
let mgr = manager(&repo.dir, Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("Hello"),
|
||||
provider: "claude".into(),
|
||||
isolation: Isolation::Worktree,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let cwd = task.cwd.0.clone();
|
||||
let git = |args: &[&str]| {
|
||||
let ok = std::process::Command::new("git")
|
||||
.args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
|
||||
.args(args)
|
||||
.current_dir(&cwd)
|
||||
.status()
|
||||
.unwrap()
|
||||
.success();
|
||||
assert!(ok, "{args:?}");
|
||||
};
|
||||
one_turn(&mgr, &task.id, None, || {
|
||||
std::fs::write(cwd.join("a.txt"), "base\nagent\n").unwrap();
|
||||
std::fs::write(cwd.join("new.txt"), "new\n").unwrap();
|
||||
git(&["add", "."]);
|
||||
git(&["commit", "-q", "-m", "agent"]);
|
||||
})
|
||||
.await;
|
||||
let rel: Vec<String> = mgr.turn_changes(&task.id).await.unwrap().into_iter().map(|c| c.rel_path).collect();
|
||||
assert_eq!(rel, ["a.txt", "new.txt"]);
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::LastTurn).await.unwrap();
|
||||
assert_eq!(std::fs::read_to_string(cwd.join("a.txt")).unwrap(), "base\n");
|
||||
assert!(!cwd.join("new.txt").exists());
|
||||
mgr.delete(&task.id, true).await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
|
||||
for eol in EOLS {
|
||||
@@ -3886,7 +3652,7 @@ async fn work_uncommitted_by_a_reset_during_a_local_task_is_not_rolled_back() {
|
||||
repo.git(&["reset", "-q", "--soft", "HEAD~1"]);
|
||||
assert_eq!(changed(&mgr, &task.id).await, ["a.txt"], "{eol:?}");
|
||||
|
||||
let base = mgr.base_text(&task.id, repo.dir.join("a.txt"), AgentChangesView::SinceStart).await.unwrap();
|
||||
let base = mgr.base_text(&task.id, repo.dir.join("a.txt")).await.unwrap();
|
||||
assert_eq!(base.map(|b| b.replace("\r\n", "\n")).as_deref(), Some("base\n"), "{eol:?}");
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert_eq!(repo.read("a.txt"), "base\n", "{eol:?}");
|
||||
@@ -4026,11 +3792,7 @@ async fn a_local_task_in_a_repository_without_commits_lists_and_rolls_back_its_c
|
||||
let (mgr, task) = repo.task().await;
|
||||
repo.write("new.txt", "agent\n");
|
||||
assert_eq!(changed(&mgr, &task.id).await, ["new.txt"], "{eol:?}");
|
||||
assert_eq!(
|
||||
mgr.base_text(&task.id, repo.dir.join("new.txt"), AgentChangesView::SinceStart).await.unwrap(),
|
||||
None,
|
||||
"{eol:?}"
|
||||
);
|
||||
assert_eq!(mgr.base_text(&task.id, repo.dir.join("new.txt")).await.unwrap(), None, "{eol:?}");
|
||||
|
||||
mgr.rollback_changes(&task.id, None, AgentChangesView::SinceStart).await.unwrap();
|
||||
assert!(!repo.dir.join("new.txt").exists(), "{eol:?}");
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
use crate::model::{AgentChange, AgentChanges, AgentCommit};
|
||||
use ide_core::{IdeError, IdeResult, IpcPath};
|
||||
use ide_vcs::{ChangeKind, LogQuery, Repo};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, UNIX_EPOCH};
|
||||
@@ -611,6 +610,7 @@ pub(crate) fn restore(
|
||||
before: &BTreeMap<String, Stamp>,
|
||||
saved: Option<&Path>,
|
||||
) -> IdeResult<()> {
|
||||
let path = &change.path.0;
|
||||
let content = match before.get(&change.rel_path) {
|
||||
Some(None) => None,
|
||||
Some(Some(_)) => {
|
||||
@@ -626,16 +626,11 @@ pub(crate) fn restore(
|
||||
None => match rev {
|
||||
Some(rev) => {
|
||||
let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
|
||||
repo.file_bytes_at(&change.path.0, Some(rev))?
|
||||
repo.file_bytes_at(path, Some(rev))?
|
||||
}
|
||||
None => None,
|
||||
},
|
||||
};
|
||||
put(&change.path.0, content)
|
||||
}
|
||||
|
||||
/// Writes `content` to `path`, or removes the file when there is none.
|
||||
fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
|
||||
match content {
|
||||
Some(bytes) => {
|
||||
if let Some(parent) = path.parent() {
|
||||
@@ -651,187 +646,6 @@ fn put(path: &Path, content: Option<Vec<u8>>) -> IdeResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The bytes of the copy of `rel` saved in `dir`, if there is one.
|
||||
pub(crate) fn saved_copy(dir: &Path, rel: &str) -> Option<Vec<u8>> {
|
||||
std::fs::read(dir.join(saved_name(rel))).ok()
|
||||
}
|
||||
|
||||
/// The checkout as the task's last turn started: what that turn's changes are compared with
|
||||
/// and rolled back to. Recorded like the task's own start: `HEAD`, the files already changed,
|
||||
/// and copies of those.
|
||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct TurnStart {
|
||||
/// `HEAD` then (`None` outside a repository or before its first commit).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub head: Option<String>,
|
||||
/// The files already changed then, stamped.
|
||||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||||
pub before: BTreeMap<String, Stamp>,
|
||||
/// The files among `before` with a copy in the task's turn folder.
|
||||
#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
|
||||
pub saved: BTreeSet<String>,
|
||||
/// The files that changed while the turn ran, recorded as it ended (`None` while it runs).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub changed: Option<BTreeSet<String>>,
|
||||
}
|
||||
|
||||
/// Records the checkout at `cwd` as a turn starts, with copies of its changed files in `dir`.
|
||||
/// The copies `previous` saved of files unchanged since are kept rather than made again, so
|
||||
/// starting a turn copies little more than what the turn before it changed.
|
||||
pub(crate) fn start_turn(cwd: &Path, dir: &Path, previous: Option<&TurnStart>) -> IdeResult<TurnStart> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(TurnStart::default()) };
|
||||
let head = repo.head()?.1;
|
||||
// As the turn's end is read, so the two compare.
|
||||
let before = snapshot(cwd)?;
|
||||
let mut saved = BTreeSet::new();
|
||||
match previous {
|
||||
Some(previous) => {
|
||||
for rel in &previous.saved {
|
||||
let unchanged =
|
||||
before.get(rel).is_some_and(|now| now.is_some() && previous.before.get(rel) == Some(now));
|
||||
if unchanged {
|
||||
saved.insert(rel.clone());
|
||||
} else {
|
||||
let _ = std::fs::remove_file(dir.join(saved_name(rel)));
|
||||
}
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
}
|
||||
for (rel, stamp) in &before {
|
||||
let path = repo.root().join(rel);
|
||||
if stamp.is_none()
|
||||
|| saved.contains(rel)
|
||||
|| !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
std::fs::create_dir_all(dir)?;
|
||||
// One that can't be copied is listed but can't be rolled back, as a large one.
|
||||
if std::fs::copy(&path, dir.join(saved_name(rel))).is_ok() {
|
||||
saved.insert(rel.clone());
|
||||
}
|
||||
}
|
||||
Ok(TurnStart { head, before, saved, changed: None })
|
||||
}
|
||||
|
||||
/// The files that changed in `cwd` since the turn `start` began: in the working tree (as
|
||||
/// `changed_between` sees them), and in the commits made since.
|
||||
pub(crate) fn changed_in_turn(cwd: &Path, start: &TurnStart) -> IdeResult<(Vec<String>, BTreeSet<String>)> {
|
||||
let end = snapshot(cwd)?;
|
||||
let worktree = changed_between(&start.before, &end);
|
||||
let mut all: BTreeSet<String> = worktree.iter().cloned().collect();
|
||||
if let Some(repo) = discover(cwd)?
|
||||
&& let (Some(from), Some(to)) = (&start.head, repo.head()?.1)
|
||||
&& *from != to
|
||||
{
|
||||
for f in repo.diff_revisions(from, &to)? {
|
||||
all.extend(f.old_path);
|
||||
all.insert(f.path);
|
||||
}
|
||||
}
|
||||
Ok((worktree, all))
|
||||
}
|
||||
|
||||
/// The content of `rel` as the turn `start` began (`None`: no file), its copies in `dir`.
|
||||
fn at_turn_start(repo: &Repo, rel: &str, start: &TurnStart, dir: &Path) -> IdeResult<Option<Vec<u8>>> {
|
||||
match start.before.get(rel) {
|
||||
Some(None) => Ok(None),
|
||||
Some(Some(_)) => match start.saved.contains(rel).then(|| saved_copy(dir, rel)).flatten() {
|
||||
Some(bytes) => Ok(Some(bytes)),
|
||||
None => Err(IdeError::invalid(format!(
|
||||
"{rel} had changes when the turn started that weren't saved; roll it back in Git instead"
|
||||
))),
|
||||
},
|
||||
None => match &start.head {
|
||||
Some(head) => repo.file_bytes_at(&repo.root().join(rel), Some(head)),
|
||||
None => Ok(None),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Added and removed lines from `old` to `new`; none for binary content.
|
||||
fn line_stats(old: Option<&[u8]>, new: Option<&[u8]>) -> (u32, u32) {
|
||||
if [old, new].iter().flatten().any(|b| b.contains(&0)) {
|
||||
return (0, 0);
|
||||
}
|
||||
let text = |b: Option<&[u8]>| b.map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();
|
||||
ide_vcs::diff_hunks(&text(old), &text(new))
|
||||
.iter()
|
||||
.fold((0, 0), |(added, removed), h| (added + h.lines, removed + h.old_lines))
|
||||
}
|
||||
|
||||
/// The files among `changed` that differ from how they were as the turn `start` began.
|
||||
pub(crate) fn turn_changes(
|
||||
cwd: &Path,
|
||||
start: &TurnStart,
|
||||
dir: &Path,
|
||||
changed: &BTreeSet<String>,
|
||||
) -> IdeResult<Vec<AgentChange>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(Vec::new()) };
|
||||
let mut out = Vec::new();
|
||||
for rel in changed {
|
||||
let path = repo.root().join(rel);
|
||||
// A folder (a submodule, say) or a file that can't be read has nothing to compare.
|
||||
let Some(now) = existing(&path) else { continue };
|
||||
let (kind, (added, removed)) = match at_turn_start(&repo, rel, start, dir) {
|
||||
Ok(then) if then == now => continue,
|
||||
Ok(then) => {
|
||||
let kind = match (&then, &now) {
|
||||
(None, _) => ChangeKind::Added,
|
||||
(_, None) => ChangeKind::Deleted,
|
||||
_ => ChangeKind::Modified,
|
||||
};
|
||||
(kind, line_stats(then.as_deref(), now.as_deref()))
|
||||
}
|
||||
// Its start wasn't saved: listed, without counts.
|
||||
Err(_) => (ChangeKind::Modified, (0, 0)),
|
||||
};
|
||||
out.push(AgentChange { path: IpcPath(path), rel_path: rel.clone(), kind, added, removed, old_path: None });
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The text of `path` as the turn `start` began, `None` when there was no file.
|
||||
pub(crate) fn turn_text(cwd: &Path, path: &Path, start: &TurnStart, dir: &Path) -> IdeResult<Option<String>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(None) };
|
||||
let rel = rel_in(repo.root(), path)?;
|
||||
if let (None, Some(head)) = (start.before.get(&rel), &start.head) {
|
||||
return file_at(cwd, path, head);
|
||||
}
|
||||
let Some(bytes) = at_turn_start(&repo, &rel, start, dir)? else { return Ok(None) };
|
||||
let encoding = match ide_vfs::load_text(path) {
|
||||
Ok(loaded) => encoding_rs::Encoding::for_label(loaded.encoding.as_bytes()).unwrap_or(encoding_rs::UTF_8),
|
||||
Err(_) => ide_vfs::detect_encoding(&bytes, None),
|
||||
};
|
||||
Ok(Some(encoding.decode(&bytes).0.into_owned()))
|
||||
}
|
||||
|
||||
/// `path` relative to the repository at `root`, with `/` separators.
|
||||
fn rel_in(root: &Path, path: &Path) -> IdeResult<String> {
|
||||
let rel = path
|
||||
.strip_prefix(root)
|
||||
.map(Path::to_path_buf)
|
||||
.ok()
|
||||
.or_else(|| {
|
||||
// Another spelling of the same place (a link, `/var` and `/private/var`); the file may be gone.
|
||||
let root = dunce::canonicalize(root).ok()?;
|
||||
let parent = dunce::canonicalize(path.parent()?).ok()?;
|
||||
Some(parent.strip_prefix(&root).ok()?.join(path.file_name()?))
|
||||
})
|
||||
.ok_or_else(|| IdeError::invalid(format!("{} is outside the repository", path.display())))?;
|
||||
Ok(rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/"))
|
||||
}
|
||||
|
||||
/// Puts `change` back as it was when the turn `start` began.
|
||||
pub(crate) fn restore_turn(cwd: &Path, start: &TurnStart, dir: &Path, change: &AgentChange) -> IdeResult<()> {
|
||||
let repo = repo_at(cwd)?;
|
||||
put(&change.path.0, at_turn_start(&repo, &change.rel_path, start, dir)?)
|
||||
}
|
||||
|
||||
pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
|
||||
let Some(repo) = discover(cwd)? else { return Ok(None) };
|
||||
let encoding = match ide_vfs::load_text(path) {
|
||||
@@ -1001,67 +815,6 @@ mod tests {
|
||||
assert!(!created.path.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_turn_copies_only_what_changed_since_the_last_one() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let repo = tmp.path().join("repo");
|
||||
std::fs::create_dir(&repo).unwrap();
|
||||
git(&repo, &["init", "-q", "-b", "main"]);
|
||||
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
|
||||
git(&repo, &["add", "."]);
|
||||
git(&repo, &["commit", "-q", "-m", "init"]);
|
||||
let dir = tmp.path().join("turn");
|
||||
let set = |names: &[&str]| names.iter().map(|n| (*n).to_owned()).collect::<BTreeSet<_>>();
|
||||
|
||||
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
|
||||
std::fs::write(repo.join("b.txt"), "b\n").unwrap();
|
||||
let first = start_turn(&repo, &dir, None).unwrap();
|
||||
assert_eq!(first.saved, set(&["a.txt", "b.txt"]));
|
||||
// A copy made again would replace this mark.
|
||||
std::fs::write(dir.join(saved_name("b.txt")), "kept\n").unwrap();
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
std::fs::write(repo.join("a.txt"), "turn two\n").unwrap();
|
||||
let second = start_turn(&repo, &dir, Some(&first)).unwrap();
|
||||
assert_eq!(second.saved, set(&["a.txt", "b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "a.txt").as_deref(), Some(&b"turn two\n"[..]));
|
||||
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"kept\n"[..]));
|
||||
|
||||
// Back as committed: nothing to keep a copy of.
|
||||
git(&repo, &["checkout", "--", "a.txt"]);
|
||||
let third = start_turn(&repo, &dir, Some(&second)).unwrap();
|
||||
assert_eq!(third.saved, set(&["b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "a.txt"), None);
|
||||
// Without a record of the last turn (a task from before), every copy is made afresh.
|
||||
let fresh = start_turn(&repo, &dir, None).unwrap();
|
||||
assert_eq!(fresh.saved, set(&["b.txt"]));
|
||||
assert_eq!(saved_copy(&dir, "b.txt").as_deref(), Some(&b"b\n"[..]));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_turns_start_is_found_through_another_spelling_of_the_checkout() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let repo = dunce::canonicalize(tmp.path()).unwrap().join("repo");
|
||||
std::fs::create_dir(&repo).unwrap();
|
||||
git(&repo, &["init", "-q", "-b", "main"]);
|
||||
std::fs::write(repo.join("a.txt"), "base\n").unwrap();
|
||||
git(&repo, &["add", "."]);
|
||||
git(&repo, &["commit", "-q", "-m", "init"]);
|
||||
std::fs::write(repo.join("a.txt"), "turn 1\n").unwrap();
|
||||
let dir = tmp.path().join("turn");
|
||||
let start = start_turn(&repo, &dir, None).unwrap();
|
||||
std::fs::write(repo.join("a.txt"), "turn 2\n").unwrap();
|
||||
std::fs::write(repo.join("new.txt"), "new\n").unwrap();
|
||||
let link = tmp.path().join("link");
|
||||
std::os::unix::fs::symlink(&repo, &link).unwrap();
|
||||
for at in [&repo, &link] {
|
||||
assert_eq!(turn_text(&repo, &at.join("a.txt"), &start, &dir).unwrap().as_deref(), Some("turn 1\n"));
|
||||
assert_eq!(turn_text(&repo, &at.join("new.txt"), &start, &dir).unwrap(), None);
|
||||
}
|
||||
assert!(turn_text(&repo, &tmp.path().join("elsewhere.txt"), &start, &dir).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commits_since_the_base_are_listed_with_their_files() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -182,7 +182,7 @@ fn collect(
|
||||
}
|
||||
|
||||
/// Scans every input, storing project inputs relative to the project.
|
||||
pub(super) fn scan_all(
|
||||
fn scan_all(
|
||||
root: &Path,
|
||||
inputs: Vec<PathBuf>,
|
||||
cancel: &CancellationToken,
|
||||
@@ -210,7 +210,7 @@ pub fn launch_fingerprint(
|
||||
if projects.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let plan = launch_plan(root, model, module, test, BuildKind::Build, cancel)?;
|
||||
let plan = launch_plan(root, model, module, test, BuildKind::Build)?;
|
||||
let Some(collected) = collect(root, &projects, &plan, local_repo)? else { return Ok(None) };
|
||||
let Collected { inputs, environment, steps, inherited_hash } = collected;
|
||||
let parameters = serde_json::to_string(&(root, module, test, steps, environment, inherited_hash, projects))
|
||||
@@ -229,7 +229,7 @@ pub fn menu_fingerprint(
|
||||
file: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Option<LaunchFingerprint>> {
|
||||
let plan = plan(root, model, BuildKind::Build, file, None, None, cancel)?;
|
||||
let plan = plan(root, model, BuildKind::Build, file, None)?;
|
||||
if plan.system != BuildSystem::Maven {
|
||||
return Ok(None);
|
||||
}
|
||||
@@ -264,23 +264,6 @@ pub fn menu_fingerprint(
|
||||
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
|
||||
}
|
||||
|
||||
/// Input fingerprint of one Maven module's menu build (#4078): its POM chain,
|
||||
/// source and resource trees plus the launcher settings that shape the build.
|
||||
/// `None` disables the module-scoped reuse (unresolved custom roots).
|
||||
/// All filesystem work belongs on the caller's blocking thread.
|
||||
pub(super) fn module_fingerprint(
|
||||
root: &Path,
|
||||
project: &maven::MavenProject,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Option<LaunchFingerprint>> {
|
||||
let projects = [project];
|
||||
let Some(inputs) = maven::launch_inputs(root, &projects, None) else { return Ok(None) };
|
||||
let parameters =
|
||||
serde_json::to_string(&("module-build", &project.dir, &project.command, &project.options, &project.env))
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
|
||||
}
|
||||
|
||||
impl LaunchFingerprint {
|
||||
/// Folders (relative to the project) of the Maven projects whose POM is an input.
|
||||
pub(super) fn project_dirs(&self) -> impl Iterator<Item = &Path> {
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
|
||||
mod fingerprint;
|
||||
mod launch_resources;
|
||||
mod modules;
|
||||
mod parse;
|
||||
mod single;
|
||||
mod structure;
|
||||
@@ -13,7 +12,6 @@ mod up_to_date;
|
||||
|
||||
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
|
||||
pub use launch_resources::process_launch_resources;
|
||||
pub use modules::record_module_build;
|
||||
pub use single::{
|
||||
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
|
||||
single_file_target,
|
||||
@@ -222,16 +220,12 @@ fn ancestors_within<'a>(root: &'a Path, file: &'a Path) -> impl Iterator<Item =
|
||||
|
||||
/// The build of `root`, or of the module containing `file` (Build Module / Recompile).
|
||||
/// `cmake`: the CMake profiles of the settings (the first one is built), if any.
|
||||
/// `cache` enables the module-scoped Maven narrowing of `Build` project builds;
|
||||
/// `None` plans every build exactly as before.
|
||||
pub fn plan(
|
||||
root: &Path,
|
||||
model: &BuildModel,
|
||||
kind: BuildKind,
|
||||
file: Option<&Path>,
|
||||
cmake: Option<&[CMakeProfile]>,
|
||||
cache: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<BuildPlan> {
|
||||
let project_name = root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned());
|
||||
let module_dir = match file {
|
||||
@@ -268,7 +262,7 @@ pub fn plan(
|
||||
None => project_name,
|
||||
};
|
||||
let steps = match system {
|
||||
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref(), cache, cancel)?,
|
||||
BuildSystem::Maven => maven_steps(root, model, kind, module_dir.as_deref())?,
|
||||
BuildSystem::Gradle => gradle_steps(root, model, kind, module_dir.as_deref())?,
|
||||
BuildSystem::Cargo => cargo_steps(&dir, kind),
|
||||
// Go builds the file's package (a module holds many).
|
||||
@@ -287,8 +281,6 @@ pub(super) fn maven_steps(
|
||||
model: &BuildModel,
|
||||
kind: BuildKind,
|
||||
module: Option<&Path>,
|
||||
cache: Option<&Path>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<BuildStep>> {
|
||||
let fallback;
|
||||
let m = match &model.maven {
|
||||
@@ -328,15 +320,7 @@ pub(super) fn maven_steps(
|
||||
s.env = p.env.clone();
|
||||
s
|
||||
};
|
||||
let Some(module) = module else {
|
||||
if kind == BuildKind::Build
|
||||
&& let Some(cache) = cache
|
||||
&& let Some(steps) = modules::narrowed_maven_steps(cache, root, m, &step, cancel)?
|
||||
{
|
||||
return Ok(steps);
|
||||
}
|
||||
return Ok(tops.iter().map(|p| step(p, &[])).collect());
|
||||
};
|
||||
let Some(module) = module else { return Ok(tops.iter().map(|p| step(p, &[])).collect()) };
|
||||
// The reactor root containing the module builds it with what it depends on (`-pl … -am`).
|
||||
let rel = rel_str(root, module);
|
||||
if !m.projects.iter().any(|p| p.dir == rel) {
|
||||
@@ -552,9 +536,7 @@ impl PathMap {
|
||||
let abs = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
// rustc prints workspace members' files relative to the workspace root, above
|
||||
// the member's manifest directory (`base`) when a member is built on its own.
|
||||
let in_base = base.and_then(|b| Path::new(b).ancestors().map(|a| a.join(p)).find(|c| c.exists()));
|
||||
let in_base = base.map(|b| Path::new(b).join(p)).filter(|c| c.exists());
|
||||
in_base.unwrap_or_else(|| cwd.join(p))
|
||||
};
|
||||
let abs = normalize(&abs);
|
||||
@@ -731,7 +713,7 @@ pub fn run(
|
||||
}
|
||||
}
|
||||
};
|
||||
let out = process::run_bounded(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let out = process::run(&step.program, &step.args, &step.cwd, &step.env, cancel, |stream, line| {
|
||||
let parsed = parser.feed(line);
|
||||
match parsed.console {
|
||||
Some(text) if text.is_empty() => {}
|
||||
@@ -773,7 +755,7 @@ pub fn run(
|
||||
if !out.success {
|
||||
success = false;
|
||||
if !messages.iter().any(|m| m.severity == Severity::Error) {
|
||||
let summary = crate::sync::error_summary(&out);
|
||||
let summary = crate::sync::error_summary(&out.text);
|
||||
let text = if summary.is_empty() { last_error_line.clone() } else { summary };
|
||||
let m = BuildMessage { severity: Severity::Error, text, path: None, range: None, code: None };
|
||||
on_event(BuildEvent::Message { message: m.clone() });
|
||||
@@ -897,15 +879,8 @@ pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Pat
|
||||
has_non_java_sources(module)
|
||||
}
|
||||
|
||||
fn launch_plan(
|
||||
root: &Path,
|
||||
model: &BuildModel,
|
||||
module: &Path,
|
||||
test: bool,
|
||||
kind: BuildKind,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<BuildPlan> {
|
||||
let mut plan = plan(root, model, kind, Some(module), None, None, cancel)?;
|
||||
fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind: BuildKind) -> IdeResult<BuildPlan> {
|
||||
let mut plan = plan(root, model, kind, Some(module), None)?;
|
||||
if plan.system == BuildSystem::Maven && !test {
|
||||
for step in &mut plan.steps {
|
||||
if let Some(goal) = step.args.last_mut() {
|
||||
@@ -932,7 +907,7 @@ pub fn build_for_launch(
|
||||
kind: BuildKind,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<LaunchBuild> {
|
||||
let plan = launch_plan(root, model, module, test, kind, cancel)?;
|
||||
let plan = launch_plan(root, model, module, test, kind)?;
|
||||
let result = run(root, &plan, cancel, &|_| {})?;
|
||||
let failure = if !result.success {
|
||||
let errors: Vec<String> = result
|
||||
@@ -997,9 +972,7 @@ mod tests {
|
||||
write(root, "../external/main.go", "package main\nimport \"example.com/lib\"\nfunc main(){_ = lib.Value()}\n");
|
||||
// std canonicalization also exercises verbatim paths on Windows.
|
||||
for root in [root.to_path_buf(), std::fs::canonicalize(root).unwrap()] {
|
||||
let plan =
|
||||
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let plan = plan(&root, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
|
||||
for step in plan.steps {
|
||||
let result = std::process::Command::new(&go)
|
||||
.args(&step.args)
|
||||
@@ -1025,7 +998,7 @@ mod tests {
|
||||
let canonical = std::fs::canonicalize(&root).unwrap();
|
||||
for root in [&root, &canonical, &canonical.join("..").join("workspace")] {
|
||||
for kind in [BuildKind::Build, BuildKind::Rebuild, BuildKind::Artifacts] {
|
||||
let p = plan(root, &BuildModel::default(), kind, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(root, &BuildModel::default(), kind, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Go);
|
||||
assert_eq!(p.steps.len(), 3);
|
||||
for (step, module) in p.steps.iter().zip(["api", "lib with spaces", "../shared"]) {
|
||||
@@ -1040,30 +1013,20 @@ mod tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
let member = plan(
|
||||
&root,
|
||||
&BuildModel::default(),
|
||||
BuildKind::Build,
|
||||
Some(&root.join("api/pkg/a.go")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let member =
|
||||
plan(&root, &BuildModel::default(), BuildKind::Build, Some(&root.join("api/pkg/a.go")), None).unwrap();
|
||||
assert_eq!(member.steps.len(), 1);
|
||||
assert_eq!(member.steps[0].cwd, root.join("api"));
|
||||
assert_eq!(member.steps[0].args, ["build", "./pkg/..."]);
|
||||
write(&root, "go.work", "use ./missing\n");
|
||||
assert!(
|
||||
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new())
|
||||
plan(&root, &BuildModel::default(), BuildKind::Build, None, None)
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.contains("go.mod")
|
||||
);
|
||||
write(&root, "go.work", "go 1.22\n");
|
||||
assert!(
|
||||
plan(&root, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
|
||||
);
|
||||
assert!(plan(&root, &BuildModel::default(), BuildKind::Build, None, None).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1084,21 +1047,11 @@ mod tests {
|
||||
let mut model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
|
||||
model.gradle[0].env.insert("JAVA_HOME".into(), "/jdk-a".into());
|
||||
model.gradle[1].env.insert("JAVA_HOME".into(), "/jdk-b".into());
|
||||
let all =
|
||||
super::plan(root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let all = super::plan(root, &model, super::BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(all.steps.len(), 2);
|
||||
assert_eq!(all.steps[0].cwd, root.join("a"));
|
||||
assert_eq!(all.steps[1].cwd, root.join("b"));
|
||||
let module = super::plan(
|
||||
root,
|
||||
&model,
|
||||
super::BuildKind::Rebuild,
|
||||
Some(&root.join("b/app")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let module = super::plan(root, &model, super::BuildKind::Rebuild, Some(&root.join("b/app")), None).unwrap();
|
||||
assert_eq!(module.steps.len(), 1);
|
||||
assert_eq!(module.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
|
||||
assert_eq!(module.steps[0].cwd, root.join("b"));
|
||||
@@ -1111,31 +1064,11 @@ mod tests {
|
||||
let mut nested = model.gradle[1].projects[1].clone();
|
||||
nested.path = ":b:app".into();
|
||||
model.gradle[0].projects.push(nested);
|
||||
let nested = super::plan(
|
||||
root,
|
||||
&model,
|
||||
super::BuildKind::Build,
|
||||
Some(&root.join("b/app")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let nested = super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).unwrap();
|
||||
assert_eq!(nested.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
|
||||
assert_eq!(nested.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
|
||||
model.gradle.clear();
|
||||
assert!(
|
||||
super::plan(
|
||||
root,
|
||||
&model,
|
||||
super::BuildKind::Build,
|
||||
Some(&root.join("b/app")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new()
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1157,24 +1090,18 @@ mod tests {
|
||||
};
|
||||
let mut model = crate::load_linked(&root, &base.join("cache"), None, &Default::default(), &settings);
|
||||
model.gradle[0].env.insert("JAVA_HOME".into(), "/external-jdk".into());
|
||||
let all =
|
||||
super::plan(&root, &model, super::BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let all = super::plan(&root, &model, super::BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(all.steps[0].cwd, external);
|
||||
// Linked roots are saved with forward slashes, so on Windows the program mixes separators.
|
||||
assert_eq!(std::path::Path::new(&all.steps[0].program), external.join(wrapper));
|
||||
let module =
|
||||
super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None, None, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let module = super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None).unwrap();
|
||||
assert_eq!(module.steps[0].cwd, external);
|
||||
assert_eq!(module.steps[0].env["JAVA_HOME"], "/external-jdk");
|
||||
assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
|
||||
let other = base.join("unlinked");
|
||||
std::fs::create_dir(&other).unwrap();
|
||||
std::fs::write(other.join("build.gradle"), "").unwrap();
|
||||
assert!(
|
||||
super::plan(&root, &model, super::BuildKind::Build, Some(&other), None, None, &CancellationToken::new())
|
||||
.is_err()
|
||||
);
|
||||
assert!(super::plan(&root, &model, super::BuildKind::Build, Some(&other), None).is_err());
|
||||
}
|
||||
use super::*;
|
||||
|
||||
@@ -1215,7 +1142,7 @@ mod tests {
|
||||
write(&root, "pom.xml", "<project><artifactId>demo</artifactId></project>");
|
||||
let model = crate::load(&root, &tmp.path().join("cache"), None);
|
||||
for (kind, expected) in [(BuildKind::Build, true), (BuildKind::Rebuild, true), (BuildKind::Artifacts, false)] {
|
||||
let plan = plan(&root, &model, kind, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let plan = plan(&root, &model, kind, None, None).unwrap();
|
||||
assert_eq!(
|
||||
plan.steps[0].args.iter().any(|arg| arg == "-Djacoco.skip=true"),
|
||||
expected,
|
||||
@@ -1236,7 +1163,7 @@ mod tests {
|
||||
write(&root, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
|
||||
write(&root, "core/src/main/java/A.java", "class A {}");
|
||||
let model = crate::load(&root, &tmp.path().join("cache"), None);
|
||||
let p = plan(&root, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&root, &model, BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Maven);
|
||||
assert_eq!(p.title, "demo");
|
||||
assert_eq!(p.steps.len(), 1);
|
||||
@@ -1244,16 +1171,7 @@ mod tests {
|
||||
p.steps[0].args,
|
||||
["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG, "-Djacoco.skip=true", "test-compile"]
|
||||
);
|
||||
let p = plan(
|
||||
&root,
|
||||
&model,
|
||||
BuildKind::Rebuild,
|
||||
Some(&root.join("core/src/main/java/A.java")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java")), None).unwrap();
|
||||
assert_eq!(
|
||||
p.steps[0].args,
|
||||
[
|
||||
@@ -1275,36 +1193,24 @@ mod tests {
|
||||
write(&g, "settings.gradle", "include 'app'");
|
||||
write(&g, "app/build.gradle", "apply plugin: 'java'");
|
||||
let model = crate::load(&g, &tmp.path().join("cache2"), None);
|
||||
let p =
|
||||
plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None, None, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Gradle);
|
||||
assert_eq!(p.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
|
||||
assert_eq!(
|
||||
plan(&g, &model, BuildKind::Artifacts, None, None, None, &CancellationToken::new()).unwrap().steps[0].args,
|
||||
plan(&g, &model, BuildKind::Artifacts, None, None).unwrap().steps[0].args,
|
||||
["--console=plain", "assemble"]
|
||||
);
|
||||
|
||||
let c = tmp.path().join("c");
|
||||
write(&c, "Cargo.toml", "[package]\nname='c'");
|
||||
let p =
|
||||
plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Cargo);
|
||||
assert_eq!(p.steps.len(), 2);
|
||||
assert_eq!(p.steps[0].args[0], "clean");
|
||||
|
||||
let go = tmp.path().join("go");
|
||||
write(&go, "go.mod", "module x");
|
||||
let p = plan(
|
||||
&go,
|
||||
&BuildModel::default(),
|
||||
BuildKind::Build,
|
||||
Some(&go.join("pkg/a/a.go")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go")), None).unwrap();
|
||||
assert_eq!(p.steps[0].args, ["build", "./pkg/a/..."]);
|
||||
assert_eq!(p.steps[0].cwd, go);
|
||||
|
||||
@@ -1312,11 +1218,9 @@ mod tests {
|
||||
write(&ts, "package.json", r#"{"scripts":{"build":"vite build"}}"#);
|
||||
write(&ts, "tsconfig.json", "{}");
|
||||
write(&ts, "pnpm-lock.yaml", "");
|
||||
let p =
|
||||
plan(&ts, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(p.steps[0].args, ["--noEmit", "--pretty", "false", "-p", "."]);
|
||||
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
|
||||
assert_eq!(
|
||||
(p.steps[0].program.as_str(), p.steps[0].args.as_slice()),
|
||||
("pnpm", &["run".to_owned(), "build".to_owned()][..])
|
||||
@@ -1329,32 +1233,21 @@ mod tests {
|
||||
write(&net, "src/Api/Api.csproj", "<Project/>");
|
||||
write(&net, "src/Api/package.json", "{}");
|
||||
write(&net, "src/Api/Program.cs", "");
|
||||
let p =
|
||||
plan(&net, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&net, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Dotnet);
|
||||
assert_eq!(p.steps[0].args, ["build", "App.sln", "-nologo", "-clp:NoSummary"]);
|
||||
assert_eq!(p.steps[0].env["MSBUILDTERMINALLOGGER"], "off");
|
||||
let p = plan(
|
||||
&net,
|
||||
&BuildModel::default(),
|
||||
BuildKind::Rebuild,
|
||||
Some(&net.join("src/Api/Program.cs")),
|
||||
None,
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let p = plan(&net, &BuildModel::default(), BuildKind::Rebuild, Some(&net.join("src/Api/Program.cs")), None)
|
||||
.unwrap();
|
||||
assert_eq!(p.steps[0].args, ["build", "Api.csproj", "-nologo", "-clp:NoSummary", "--no-incremental"]);
|
||||
assert_eq!(p.steps[0].cwd, net.join("src/Api"));
|
||||
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None, None, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
|
||||
assert_eq!(p.steps[0].args[0], "publish");
|
||||
|
||||
let cm = tmp.path().join("cm");
|
||||
write(&cm, "CMakeLists.txt", "project(app)");
|
||||
let args = |p: &BuildPlan| p.steps.iter().map(|s| s.args.join(" ")).collect::<Vec<_>>();
|
||||
let p =
|
||||
plan(&cm, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::CMake);
|
||||
assert_eq!(
|
||||
args(&p),
|
||||
@@ -1365,8 +1258,7 @@ mod tests {
|
||||
"an unconfigured project is configured first"
|
||||
);
|
||||
write(&cm, "cmake-build-release/CMakeCache.txt", "");
|
||||
let p =
|
||||
plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
|
||||
assert_eq!(
|
||||
args(&p),
|
||||
["--build cmake-build-release --config Debug --clean-first"],
|
||||
@@ -1378,34 +1270,17 @@ mod tests {
|
||||
build_args: vec!["-j".into(), "8".into()],
|
||||
..CMakeProfile::default()
|
||||
};
|
||||
let p = plan(
|
||||
&cm,
|
||||
&BuildModel::default(),
|
||||
BuildKind::Build,
|
||||
None,
|
||||
Some(std::slice::from_ref(&profile)),
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let p =
|
||||
plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(std::slice::from_ref(&profile))).unwrap();
|
||||
assert_eq!(args(&p), ["--build cmake-build-release --config Release -j 8"]);
|
||||
let p = plan(
|
||||
&cm,
|
||||
&BuildModel::default(),
|
||||
BuildKind::Build,
|
||||
None,
|
||||
Some(&[CMakeProfile::default()]),
|
||||
None,
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(&[CMakeProfile::default()])).unwrap();
|
||||
assert_eq!(p.steps[0].args[..4], ["-S", ".", "-B", "cmake-build-debug"]);
|
||||
|
||||
let siblings = tmp.path().join("siblings");
|
||||
write(&siblings, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
|
||||
write(&siblings, "system/pom.xml", "<project><artifactId>system</artifactId></project>");
|
||||
let model = crate::load(&siblings, &tmp.path().join("cache3"), None);
|
||||
let p = plan(&siblings, &model, BuildKind::Build, None, None, None, &CancellationToken::new()).unwrap();
|
||||
let p = plan(&siblings, &model, BuildKind::Build, None, None).unwrap();
|
||||
assert_eq!(p.system, BuildSystem::Maven);
|
||||
assert_eq!(
|
||||
p.steps.iter().map(|s| s.cwd.clone()).collect::<Vec<_>>(),
|
||||
@@ -1414,9 +1289,7 @@ mod tests {
|
||||
|
||||
let none = tmp.path().join("none");
|
||||
std::fs::create_dir_all(&none).unwrap();
|
||||
assert!(
|
||||
plan(&none, &BuildModel::default(), BuildKind::Build, None, None, None, &CancellationToken::new()).is_err()
|
||||
);
|
||||
assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None, None).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1430,22 +1303,6 @@ mod tests {
|
||||
assert_eq!(identifier_len("x é_1 c", 2), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_a_member_build_s_workspace_relative_paths() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
write(&root, "client/src/main.rs", "fn main() {}\n");
|
||||
write(&root, "client/src/lib.rs", "\n");
|
||||
write(&root, "src/lib.rs", "\n");
|
||||
let map = PathMap { root: root.clone(), canonical: None };
|
||||
let member = root.join("client");
|
||||
let base = member.to_str();
|
||||
// Build Module runs in the member; rustc names its files from the workspace root.
|
||||
assert_eq!(map.resolve("client/src/main.rs", &member, base), root.join("client/src/main.rs"));
|
||||
// A crate built from its own directory names them from there.
|
||||
assert_eq!(map.resolve("src/lib.rs", &member, base), member.join("src/lib.rs"));
|
||||
}
|
||||
|
||||
// Uses Unix absolute paths for the canonical root.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
@@ -1615,8 +1472,7 @@ mod tests {
|
||||
let model = reactor_model();
|
||||
for (test, goal) in [(false, "compile"), (true, "test-compile")] {
|
||||
// A normal launch is incremental: no `clean` (IDEA's Make, not Rebuild).
|
||||
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build).unwrap();
|
||||
let step = &plan.steps[0];
|
||||
assert_eq!(step.cwd, root);
|
||||
assert_eq!(step.program, "mvnw");
|
||||
@@ -1637,9 +1493,7 @@ mod tests {
|
||||
]
|
||||
);
|
||||
// Rebuild cleans first, as IDEA's Rebuild does.
|
||||
let plan =
|
||||
launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild, &CancellationToken::new())
|
||||
.unwrap();
|
||||
let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild).unwrap();
|
||||
assert_eq!(
|
||||
plan.steps[0].args,
|
||||
[
|
||||
|
||||
@@ -1,408 +0,0 @@
|
||||
//! Module-scoped Maven menu builds (`Build Project` on a multi-module reactor, #4078).
|
||||
//!
|
||||
//! A project build used to run every linked reactor from end to end; only the
|
||||
//! all-or-nothing up-to-date check could skip it, so one edited file anywhere
|
||||
//! paid a full reactor build. This module narrows the scope: per-module input
|
||||
//! fingerprints recorded after the last successful build tell which modules'
|
||||
//! sources, resources, POM chain or outputs changed, the module dependency graph
|
||||
//! spreads that to the modules depending on them, and the reactor runs
|
||||
//! `mvn -pl <modules> -am` over just that set. Maven still decides what
|
||||
//! recompiles inside the selected modules; `-am` keeps the upstream modules a
|
||||
//! changed module was built against. Reactors without a usable record, and any
|
||||
//! analysis that cannot resolve its inputs, build everything as before.
|
||||
|
||||
use super::up_to_date::restamp;
|
||||
use super::*;
|
||||
use std::fs;
|
||||
|
||||
/// The per-module input fingerprints of one reactor's last successful build.
|
||||
#[derive(serde::Serialize, serde::Deserialize)]
|
||||
struct ReactorRecord {
|
||||
/// Module directory (project-relative, `/`-separated) → its record.
|
||||
modules: BTreeMap<String, ModuleRecord>,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, serde::Deserialize)]
|
||||
struct ModuleRecord {
|
||||
fingerprint: LaunchFingerprint,
|
||||
/// Output folders of the module that existed after the build, relative to the
|
||||
/// project. Deleting one outside the IDE (`mvn clean` in a terminal) leaves every
|
||||
/// input unchanged, so the module is rebuilt only while they are gone.
|
||||
outputs: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
fn record_path(cache: &Path, top_dir: &str) -> PathBuf {
|
||||
let base = cache.join("menu-build").join("modules");
|
||||
if top_dir.is_empty() { base.join("root.json") } else { base.join(format!("{top_dir}.json")) }
|
||||
}
|
||||
|
||||
fn load_record(cache: &Path, top_dir: &str) -> Option<ReactorRecord> {
|
||||
let bytes = fs::read(record_path(cache, top_dir)).ok()?;
|
||||
serde_json::from_slice(&bytes).ok()
|
||||
}
|
||||
|
||||
/// Projects of `reactor` that (transitively) depend on one of `changed`, through
|
||||
/// dependencies whose version matches the provider. The reverse of the launch
|
||||
/// upstream walk: a changed module's new classes force its consumers to recompile,
|
||||
/// `test`-scoped ones included, since the project build compiles every module's tests.
|
||||
fn affected_projects(reactor: &[&maven::MavenProject], changed: &HashSet<String>) -> HashSet<String> {
|
||||
let mut affected = changed.clone();
|
||||
let mut pending: Vec<&str> = changed.iter().map(String::as_str).collect();
|
||||
while let Some(dir) = pending.pop() {
|
||||
let Some(upstream) = reactor.iter().find(|p| p.dir == dir) else { continue };
|
||||
for consumer in reactor {
|
||||
if affected.contains(&consumer.dir) {
|
||||
continue;
|
||||
}
|
||||
let depends = consumer.dependencies.iter().any(|d| {
|
||||
d.resolved()
|
||||
&& upstream.group_id == d.group_id
|
||||
&& upstream.artifact_id == d.artifact_id
|
||||
&& d.version.as_ref().is_none_or(|v| *v == upstream.version)
|
||||
});
|
||||
if depends {
|
||||
affected.insert(consumer.dir.clone());
|
||||
pending.push(consumer.dir.as_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
affected
|
||||
}
|
||||
|
||||
/// `-pl` entries of the affected modules, relative to the reactor root the step
|
||||
/// runs in, sorted so the command line does not depend on the model's project
|
||||
/// order (Maven reorders the selection into its own reactor order anyway).
|
||||
fn selection(reactor: &[&maven::MavenProject], top_dir: &str, affected: &HashSet<String>) -> String {
|
||||
let mut entries: Vec<String> = reactor
|
||||
.iter()
|
||||
.filter(|p| affected.contains(&p.dir))
|
||||
.map(|p| {
|
||||
Path::new(&p.dir).strip_prefix(top_dir).unwrap_or(Path::new(&p.dir)).to_string_lossy().replace('\\', "/")
|
||||
})
|
||||
.collect();
|
||||
entries.sort();
|
||||
entries.join(",")
|
||||
}
|
||||
|
||||
/// Narrowed `Build Project` steps: per reactor, one full step when the reactor
|
||||
/// or most of it is affected, one `-pl <modules> -am` step for the affected
|
||||
/// subset, or no step at all when nothing changed since the last successful
|
||||
/// build. `None` = some module's inputs cannot be fingerprinted, so the caller
|
||||
/// falls back to the unscoped build. The `step` closure builds a reactor step
|
||||
/// with the caller's goals and options.
|
||||
pub(super) fn narrowed_maven_steps(
|
||||
cache: &Path,
|
||||
root: &Path,
|
||||
m: &maven::MavenModel,
|
||||
step: &impl Fn(&maven::MavenProject, &[String]) -> BuildStep,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Option<Vec<BuildStep>>> {
|
||||
let mut steps = Vec::new();
|
||||
for top in m.projects.iter().filter(|p| !p.aggregated) {
|
||||
let Some(record) = load_record(cache, &top.dir) else {
|
||||
steps.push(step(top, &[]));
|
||||
continue;
|
||||
};
|
||||
let reactor = reactor_projects(m, top);
|
||||
let mut changed = HashSet::new();
|
||||
let mut lying: Vec<PathBuf> = Vec::new();
|
||||
for project in &reactor {
|
||||
let Some(current) = fingerprint::module_fingerprint(root, project, cancel)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
let Some(recorded) = record.modules.get(&project.dir) else {
|
||||
changed.insert(project.dir.clone());
|
||||
continue;
|
||||
};
|
||||
if recorded.fingerprint != current {
|
||||
changed.insert(project.dir.clone());
|
||||
lying.extend(recorded.fingerprint.mtime_preserved_edits(¤t));
|
||||
}
|
||||
if !recorded.outputs.iter().all(|out| root.join(out).is_dir()) {
|
||||
changed.insert(project.dir.clone());
|
||||
}
|
||||
}
|
||||
if changed.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let affected = affected_projects(&reactor, &changed);
|
||||
restamp(root, &lying);
|
||||
if affected.len() >= reactor.len() || affected.contains(&top.dir) {
|
||||
steps.push(step(top, &[]));
|
||||
} else {
|
||||
let pl = selection(&reactor, &top.dir, &affected);
|
||||
steps.push(step(top, &["-pl".into(), pl, "-am".into()]));
|
||||
}
|
||||
}
|
||||
Ok(Some(steps))
|
||||
}
|
||||
|
||||
/// Records the per-module inputs of every linked reactor as the baseline of the
|
||||
/// next narrowed build. Failures are swallowed: a missing record only costs one
|
||||
/// unscoped Maven run. Called after a successful project build.
|
||||
pub fn record_module_build(cache: &Path, root: &Path, model: &BuildModel, cancel: &CancellationToken) {
|
||||
let Some(m) = &model.maven else { return };
|
||||
for top in m.projects.iter().filter(|p| !p.aggregated) {
|
||||
let mut modules = BTreeMap::new();
|
||||
for project in reactor_projects(m, top) {
|
||||
let Ok(Some(fingerprint)) = fingerprint::module_fingerprint(root, project, cancel) else { continue };
|
||||
let outputs = ["target/classes", "target/test-classes"]
|
||||
.iter()
|
||||
.map(|out| Path::new(&project.dir).join(out))
|
||||
.filter(|rel| root.join(rel).is_dir())
|
||||
.collect();
|
||||
modules.insert(project.dir.clone(), ModuleRecord { fingerprint, outputs });
|
||||
}
|
||||
let path = record_path(cache, &top.dir);
|
||||
if path.parent().is_some_and(|p| fs::create_dir_all(p).is_err()) {
|
||||
continue;
|
||||
}
|
||||
let Ok(bytes) = serde_json::to_vec(&ReactorRecord { modules }) else { continue };
|
||||
let _ = fs::write(&path, bytes);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn write(root: &Path, rel: &str, value: &str) {
|
||||
let path = root.join(rel);
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(path, value).unwrap();
|
||||
}
|
||||
|
||||
/// `other` ← nothing, `app` ← `mid` ← `lib`, all under one reactor root.
|
||||
fn fixture(root: &Path) -> BuildModel {
|
||||
write(
|
||||
root,
|
||||
"pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module><module>other</module></modules></project>"#,
|
||||
);
|
||||
for (dir, class, deps) in [
|
||||
("lib", "L", ""),
|
||||
(
|
||||
"mid",
|
||||
"M",
|
||||
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
|
||||
),
|
||||
(
|
||||
"app",
|
||||
"A",
|
||||
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
|
||||
),
|
||||
("other", "O", ""),
|
||||
] {
|
||||
write(
|
||||
root,
|
||||
&format!("{dir}/pom.xml"),
|
||||
&format!(
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
|
||||
),
|
||||
);
|
||||
write(
|
||||
root,
|
||||
&format!("{dir}/src/main/java/t/{class}.java"),
|
||||
&format!("package t; public class {class} {{}}"),
|
||||
);
|
||||
}
|
||||
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
|
||||
}
|
||||
|
||||
fn steps(cache: &Path, root: &Path, model: &BuildModel) -> Option<Vec<BuildStep>> {
|
||||
narrowed_maven_steps(
|
||||
cache,
|
||||
root,
|
||||
model.maven.as_ref().unwrap(),
|
||||
&|p, extra| {
|
||||
let mut s = BuildStep::new(&p.command, &["-B"], &subdir(root, &p.dir), Format::Maven);
|
||||
s.args.extend(extra.iter().cloned());
|
||||
s.args.push("test-compile".into());
|
||||
s
|
||||
},
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn pl_arg(step: &BuildStep) -> String {
|
||||
let i = step.args.iter().position(|a| a == "-pl").unwrap();
|
||||
step.args[i + 1].clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_module_selects_itself_and_transitive_dependents() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
write(root, "lib/src/main/java/t/L.java", "package t; public class L { int x; }");
|
||||
let steps = steps(&cache, root, &model).unwrap();
|
||||
assert_eq!(steps.len(), 1);
|
||||
assert_eq!(pl_arg(&steps[0]), "app,lib,mid");
|
||||
assert!(steps[0].args.contains(&"-am".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unchanged_reactor_runs_nothing() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
assert!(steps(&cache, root, &model).unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_or_corrupt_record_builds_everything() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
fs::create_dir_all(cache.join("menu-build").join("modules")).unwrap();
|
||||
fs::write(cache.join("menu-build").join("modules").join("root.json"), b"{not json").unwrap();
|
||||
assert_eq!(steps(&cache, root, &model).unwrap().len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deleted_output_rebuilds_the_module_without_spreading() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
for out in ["mid/target/classes/t", "other/target/classes"] {
|
||||
fs::create_dir_all(root.join(out)).unwrap();
|
||||
}
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
fs::remove_dir_all(root.join("mid/target")).unwrap();
|
||||
let steps = steps(&cache, root, &model).unwrap();
|
||||
assert_eq!(pl_arg(&steps[0]), "app,mid");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mtime_preserved_edit_is_restamped_before_the_build() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
let rel = "lib/src/main/java/t/L.java";
|
||||
write(root, rel, "package t; public class L { int x; }");
|
||||
let mtime = fs::metadata(root.join(rel)).unwrap().modified().unwrap();
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
write(root, rel, "package t; public class L { int z; }");
|
||||
fs::File::options().write(true).open(root.join(rel)).unwrap().set_modified(mtime).unwrap();
|
||||
assert!(!steps(&cache, root, &model).unwrap().is_empty());
|
||||
assert!(fs::metadata(root.join(rel)).unwrap().modified().unwrap() > mtime);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_scoped_consumers_are_rebuilt_and_version_mismatch_does_not_spread() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
write(
|
||||
root,
|
||||
"pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>tester</module><module>v2</module></modules></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
"lib/pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>lib</artifactId></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
"tester/pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>tester</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version><scope>test</scope></dependency></dependencies></project>"#,
|
||||
);
|
||||
write(
|
||||
root,
|
||||
"v2/pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>v2</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>2</version></dependency></dependencies></project>"#,
|
||||
);
|
||||
for module in ["lib", "tester", "v2"] {
|
||||
write(root, &format!("{module}/src/main/java/t/{module}.java"), "package t;");
|
||||
}
|
||||
let model = BuildModel { maven: Some(maven::load(root)), ..Default::default() };
|
||||
let cache = root.join("cache");
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
write(root, "lib/src/main/java/t/L.java", "package t; public class L {}");
|
||||
let steps = steps(&cache, root, &model).unwrap();
|
||||
// `tester`'s tests compile against `lib`.
|
||||
assert_eq!(pl_arg(&steps[0]), "lib,tester");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn root_pom_change_selects_the_whole_reactor() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = fixture(root);
|
||||
let cache = root.join("cache");
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
write(
|
||||
root,
|
||||
"pom.xml",
|
||||
fs::read_to_string(root.join("pom.xml")).unwrap().replace("<modules>", "<!-- x --><modules>").as_str(),
|
||||
);
|
||||
let steps = steps(&cache, root, &model).unwrap();
|
||||
assert_eq!(steps.len(), 1);
|
||||
assert!(!steps[0].args.contains(&"-pl".into()));
|
||||
}
|
||||
|
||||
/// A folder of two sibling reactors: `chain` (lib ← mid ← app) and `solo`.
|
||||
fn two_reactors(root: &Path) -> BuildModel {
|
||||
write(
|
||||
root,
|
||||
"chain/pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>chain</artifactId><version>1</version><packaging>pom</packaging><modules><module>lib</module><module>mid</module><module>app</module></modules></project>"#,
|
||||
);
|
||||
for (dir, class, deps) in [
|
||||
("lib", "L", ""),
|
||||
(
|
||||
"mid",
|
||||
"M",
|
||||
"<dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies>",
|
||||
),
|
||||
(
|
||||
"app",
|
||||
"A",
|
||||
"<dependencies><dependency><groupId>t</groupId><artifactId>mid</artifactId><version>1</version></dependency></dependencies>",
|
||||
),
|
||||
] {
|
||||
write(
|
||||
root,
|
||||
&format!("chain/{dir}/pom.xml"),
|
||||
&format!(
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>chain</artifactId><version>1</version></parent><artifactId>{dir}</artifactId>{deps}</project>"#
|
||||
),
|
||||
);
|
||||
write(
|
||||
root,
|
||||
&format!("chain/{dir}/src/main/java/t/{class}.java"),
|
||||
&format!("package t; public class {class} {{}}"),
|
||||
);
|
||||
}
|
||||
write(
|
||||
root,
|
||||
"solo/pom.xml",
|
||||
r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>solo</artifactId><version>1</version></project>"#,
|
||||
);
|
||||
write(root, "solo/src/main/java/t/S.java", "package t;");
|
||||
BuildModel { maven: Some(maven::load(root)), ..Default::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unrelated_reactors_are_judged_separately() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path();
|
||||
let model = two_reactors(root);
|
||||
let cache = root.join("cache");
|
||||
record_module_build(&cache, root, &model, &CancellationToken::new());
|
||||
write(root, "solo/src/main/java/t/S.java", "package t; public class S {}");
|
||||
let steps = steps(&cache, root, &model).unwrap();
|
||||
assert_eq!(steps.len(), 1);
|
||||
assert_eq!(steps[0].cwd, subdir(root, "solo"));
|
||||
}
|
||||
}
|
||||
@@ -41,7 +41,7 @@ fn record_path(cache: &Path, root: &Path, file: Option<&Path>) -> PathBuf {
|
||||
/// Re-stamps files whose content changed without advancing mtime (git
|
||||
/// checkout, external sync): timestamp-incremental Maven would otherwise skip
|
||||
/// them as "unchanged" and the rebuild would compile nothing.
|
||||
pub(super) fn restamp(root: &Path, edits: &[PathBuf]) {
|
||||
fn restamp(root: &Path, edits: &[PathBuf]) {
|
||||
let now = std::time::SystemTime::now();
|
||||
for rel in edits {
|
||||
let path = root.join(rel);
|
||||
|
||||
@@ -30,7 +30,6 @@ def processedResources = { Project p, s ->
|
||||
def describe = { Project p ->
|
||||
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
|
||||
if (p.gradle.parent != null) m.build = identity(p.rootProject)
|
||||
m.resolvableConfigurations = p.configurations.findAll { it.canBeResolved }.collect { it.name }.sort()
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
|
||||
@@ -41,10 +41,6 @@ pub struct GradleProject {
|
||||
/// Project-relative build script, if any.
|
||||
pub build_file: Option<String>,
|
||||
pub tasks: Vec<GradleTask>,
|
||||
/// Configurations Gradle can resolve, or null before Gradle reports the project.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
|
||||
/// `:buildSrc`); null for the opened build.
|
||||
#[serde(default)]
|
||||
@@ -305,7 +301,6 @@ fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradlePro
|
||||
path,
|
||||
name,
|
||||
tasks,
|
||||
resolvable_configurations: None,
|
||||
build: None,
|
||||
}
|
||||
}
|
||||
@@ -322,8 +317,6 @@ pub struct ReportedProject {
|
||||
pub build_dir: Option<String>,
|
||||
#[serde(default)]
|
||||
pub source_sets: Vec<ReportedSourceSet>,
|
||||
#[serde(default)]
|
||||
pub resolvable_configurations: Option<Vec<String>>,
|
||||
/// Toolchain language version, else target compatibility.
|
||||
#[serde(default)]
|
||||
pub java: Option<u32>,
|
||||
@@ -419,7 +412,6 @@ pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &
|
||||
if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
|
||||
project.tasks.clear();
|
||||
}
|
||||
project.resolvable_configurations = p.resolvable_configurations.clone();
|
||||
project.build = p.build.clone();
|
||||
project
|
||||
})
|
||||
@@ -1638,11 +1630,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
path: path.into(),
|
||||
dir: ws.join(d).to_string_lossy().into_owned(),
|
||||
build: build.map(Into::into),
|
||||
resolvable_configurations: match path {
|
||||
":" => Some(vec!["reviewTools".into(), "runtimeClasspath".into()]),
|
||||
":lib:core" => Some(Vec::new()),
|
||||
_ => None,
|
||||
},
|
||||
..ReportedProject::default()
|
||||
};
|
||||
format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
|
||||
@@ -1671,12 +1658,6 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
|
||||
);
|
||||
let build_src = &model.projects[2];
|
||||
assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
|
||||
assert_eq!(
|
||||
model.projects[0].resolvable_configurations,
|
||||
Some(vec!["reviewTools".into(), "runtimeClasspath".into()])
|
||||
);
|
||||
assert_eq!(model.projects[1].resolvable_configurations, None);
|
||||
assert_eq!(model.projects[4].resolvable_configurations, Some(Vec::new()));
|
||||
assert!(!model.projects[4].tasks.is_empty());
|
||||
assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ pub fn gradle_dependencies(
|
||||
configuration: &str,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<GradleDependency>> {
|
||||
if configuration.is_empty() || !configuration.chars().all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | '.')) {
|
||||
if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
|
||||
return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
|
||||
}
|
||||
if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
|
||||
@@ -143,7 +143,7 @@ pub fn gradle_dependencies(
|
||||
}
|
||||
let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
|
||||
let mut args: Vec<String> =
|
||||
vec!["--console=plain".into(), "-q".into(), task, format!("--configuration={configuration}")];
|
||||
vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
|
||||
if options.offline {
|
||||
args.push("--offline".into());
|
||||
}
|
||||
@@ -156,10 +156,7 @@ pub fn gradle_dependencies(
|
||||
|_, _| {},
|
||||
)?;
|
||||
if !out.success {
|
||||
return Err(IdeError::unavailable(error_summary(&out)));
|
||||
}
|
||||
if let Some(note) = sync::truncation_note(&out) {
|
||||
return Err(IdeError::unavailable(note));
|
||||
return Err(IdeError::unavailable(error_summary(&out.text)));
|
||||
}
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
@@ -340,14 +337,14 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
&gradle::load(root).unwrap(),
|
||||
&options,
|
||||
":app",
|
||||
"review.tools",
|
||||
"testRuntimeClasspath",
|
||||
&CancellationToken::new(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(root.join("args")).unwrap().trim(),
|
||||
"--console=plain -q :app:dependencies --configuration=review.tools --offline"
|
||||
"--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -78,14 +78,14 @@ fn has_kotlin_sources(root: &Path) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
fn plan(root: &Path, model: &BuildModel, cancel: &CancellationToken) -> IdeResult<compile::BuildPlan> {
|
||||
fn plan(root: &Path, model: &BuildModel) -> IdeResult<compile::BuildPlan> {
|
||||
if model.maven.as_ref().is_none_or(|m| m.projects.is_empty()) {
|
||||
return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
|
||||
}
|
||||
Ok(compile::BuildPlan {
|
||||
system: compile::BuildSystem::Maven,
|
||||
title: root.file_name().unwrap_or_default().to_string_lossy().into_owned(),
|
||||
steps: compile::maven_steps(root, model, BuildKind::Build, None, None, cancel)?,
|
||||
steps: compile::maven_steps(root, model, BuildKind::Build, None)?,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -99,7 +99,7 @@ pub fn build(
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Outcome> {
|
||||
std::fs::create_dir_all(generation)?;
|
||||
let mut plan = plan(root, model, cancel)?;
|
||||
let mut plan = plan(root, model)?;
|
||||
let mut manifests = Vec::new();
|
||||
for (index, step) in plan.steps.iter_mut().enumerate() {
|
||||
step.args.push("--fail-at-end".into());
|
||||
@@ -522,7 +522,7 @@ mod tests {
|
||||
}
|
||||
std::fs::write(root.join("kotlin/App.kt"), "class App").unwrap();
|
||||
assert!(has_kotlin(root, &model), "{marker}");
|
||||
let plan = plan(root, &model, &CancellationToken::new()).unwrap();
|
||||
let plan = plan(root, &model).unwrap();
|
||||
assert_eq!(plan.system, compile::BuildSystem::Maven);
|
||||
assert_eq!(plan.steps.len(), 2);
|
||||
for (step, name) in plan.steps.iter().zip(["java", "kotlin"]) {
|
||||
@@ -562,7 +562,7 @@ mod tests {
|
||||
..Default::default()
|
||||
};
|
||||
assert!(has_kotlin(workspace.path(), &model));
|
||||
assert_eq!(plan(workspace.path(), &model, &CancellationToken::new()).unwrap().steps[0].cwd, external.path());
|
||||
assert_eq!(plan(workspace.path(), &model).unwrap().steps[0].cwd, external.path());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -13,8 +13,6 @@ pub mod kotlin_bridge;
|
||||
pub mod maven;
|
||||
pub mod pom_edit;
|
||||
mod process;
|
||||
#[cfg(test)]
|
||||
mod process_numbers;
|
||||
pub mod sbt;
|
||||
mod sync;
|
||||
pub mod web;
|
||||
|
||||
@@ -1875,14 +1875,6 @@ pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<Pa
|
||||
goto_declaration_in(text, path, pos, local_repo, Vec::new)
|
||||
}
|
||||
|
||||
/// The declaration of the property `name` in the pom at `path`, for files it configures
|
||||
/// outside the pom itself (a YAML resource's `@name@`): the first `<properties>` entry
|
||||
/// along the parent chain declaring it, `project.*` built-ins included.
|
||||
pub fn property_declaration(pom: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
|
||||
let text = xml::read_text(pom)?;
|
||||
property_target(&text, pom, name, local_repo)
|
||||
}
|
||||
|
||||
/// [`goto_declaration`], where a `<parent>` and a dependency or plugin whose version no
|
||||
/// management entry provides (or a management entry itself) go to the artifact's own
|
||||
/// POM: the project module among `modules` with its coordinates, else the local
|
||||
|
||||
@@ -17,72 +17,10 @@ pub(crate) enum Stream {
|
||||
Stderr,
|
||||
}
|
||||
|
||||
/// A single line longer than this without a newline is delivered as several lines: the pump
|
||||
/// buffer stays bounded whatever the child prints (progress bars, minified bundles, binary
|
||||
/// output), and every byte still arrives.
|
||||
pub(crate) const MAX_LINE_BYTES: usize = 1024 * 1024;
|
||||
/// `Output::text` stops growing past this while the pipes keep draining: a chatty build can
|
||||
/// print far more than is ever parsed back out of the retained copy.
|
||||
pub(crate) const MAX_TEXT_BYTES: usize = 32 * 1024 * 1024;
|
||||
|
||||
pub(crate) struct Output {
|
||||
pub success: bool,
|
||||
/// Every line, stdout and stderr interleaved as received, up to [`MAX_TEXT_BYTES`].
|
||||
/// Every line, stdout and stderr interleaved as received.
|
||||
pub text: String,
|
||||
/// More output followed the retained `text`; the lines were still fed to `on_line`.
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
/// Bounded pump for callers that stream every line and only summarize errors: reads fixed
|
||||
/// 64 KiB chunks, splits newline-free runs at a UTF-8 char boundary at the line cap, and
|
||||
/// never grows one line buffer without bound.
|
||||
fn pump_bounded(stream: Box<dyn Read + Send>, kind: Stream, tx: &mpsc::Sender<(Stream, String)>) {
|
||||
let mut reader = BufReader::new(stream);
|
||||
// `terminated`: the buffer ends in the stream's newline. A segment cut from a
|
||||
// newline-free run at the line cap must keep a trailing `\r` — it is data.
|
||||
let send = |buf: &mut Vec<u8>, terminated: bool, tx: &mpsc::Sender<(Stream, String)>| {
|
||||
let line = ide_core::output_encoding::decode_tool_output(buf);
|
||||
let line = if terminated { line.trim_end_matches(['\n', '\r']).to_owned() } else { line };
|
||||
buf.clear();
|
||||
tx.send((kind, line)).is_ok()
|
||||
};
|
||||
let mut chunk = vec![0u8; 64 * 1024];
|
||||
let mut line: Vec<u8> = Vec::with_capacity(256);
|
||||
'read: loop {
|
||||
let n = match reader.read(&mut chunk) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => n,
|
||||
};
|
||||
let mut start = 0;
|
||||
for (i, &b) in chunk[..n].iter().enumerate() {
|
||||
if b == b'\n' {
|
||||
line.extend_from_slice(&chunk[start..=i]);
|
||||
if !send(&mut line, true, tx) {
|
||||
break 'read;
|
||||
}
|
||||
start = i + 1;
|
||||
}
|
||||
}
|
||||
line.extend_from_slice(&chunk[start..n]);
|
||||
while line.len() > MAX_LINE_BYTES {
|
||||
let mut at = MAX_LINE_BYTES;
|
||||
while at > 0 && line[at] & 0xC0 == 0x80 {
|
||||
at -= 1;
|
||||
}
|
||||
// Malformed input with no boundary at all: split raw and let decoding say so.
|
||||
if at == 0 {
|
||||
at = MAX_LINE_BYTES;
|
||||
}
|
||||
let rest = line.split_off(at);
|
||||
if !send(&mut line, false, tx) {
|
||||
break 'read;
|
||||
}
|
||||
line = rest;
|
||||
}
|
||||
}
|
||||
if !line.is_empty() {
|
||||
send(&mut line, true, tx);
|
||||
}
|
||||
}
|
||||
|
||||
/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's
|
||||
@@ -103,8 +41,7 @@ pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>, cwd: &
|
||||
}
|
||||
|
||||
/// Runs `program args` in `cwd`, feeding each output line to `on_line`; kills
|
||||
/// the process group and returns `cancelled` when `cancel` fires. `Output.text`
|
||||
/// keeps every line: callers that parse a complete model from it use this.
|
||||
/// the process group and returns `cancelled` when `cancel` fires.
|
||||
pub(crate) fn run(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
@@ -116,20 +53,6 @@ pub(crate) fn run(
|
||||
run_with_env(program, args, cwd, env, false, cancel, on_line)
|
||||
}
|
||||
|
||||
/// Like [`run`], but bounds both the per-line buffer and the retained copy. For callers
|
||||
/// that stream every line to `on_line` and use `Output.text` only for error summaries:
|
||||
/// sync/model listings must be kept whole and use [`run`] instead.
|
||||
pub(crate) fn run_bounded(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
cwd: &Path,
|
||||
env: &BTreeMap<String, String>,
|
||||
cancel: &CancellationToken,
|
||||
on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
run_with_env_capture(program, args, cwd, env, RunOptions { bounded: true, ..Default::default() }, cancel, on_line)
|
||||
}
|
||||
|
||||
pub(crate) fn run_with_env(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
@@ -137,27 +60,8 @@ pub(crate) fn run_with_env(
|
||||
env: &BTreeMap<String, String>,
|
||||
clear_env: bool,
|
||||
cancel: &CancellationToken,
|
||||
on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
run_with_env_capture(program, args, cwd, env, RunOptions { clear_env, ..Default::default() }, cancel, on_line)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Default)]
|
||||
struct RunOptions {
|
||||
clear_env: bool,
|
||||
bounded: bool,
|
||||
}
|
||||
|
||||
fn run_with_env_capture(
|
||||
program: &str,
|
||||
args: &[String],
|
||||
cwd: &Path,
|
||||
env: &BTreeMap<String, String>,
|
||||
options: RunOptions,
|
||||
cancel: &CancellationToken,
|
||||
mut on_line: impl FnMut(Stream, &str),
|
||||
) -> IdeResult<Output> {
|
||||
let RunOptions { clear_env, bounded } = options;
|
||||
tracing::info!("build: {program} {} (in {})", args.join(" "), cwd.display());
|
||||
// Output is read as UTF-8: JVMs on Windows are told to write it (see `ide_core::output_encoding`).
|
||||
let encoding =
|
||||
@@ -176,22 +80,17 @@ fn run_with_env_capture(
|
||||
let (tx, rx) = mpsc::channel::<(Stream, String)>();
|
||||
let pump = |stream: Box<dyn Read + Send>, kind: Stream, tx: mpsc::Sender<(Stream, String)>| {
|
||||
std::thread::spawn(move || {
|
||||
if bounded {
|
||||
pump_bounded(stream, kind, &tx);
|
||||
} else {
|
||||
// Model listings are parsed from Output.text: keep every line whole, however long.
|
||||
let mut reader = BufReader::new(stream);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let line = ide_core::output_encoding::decode_tool_output(&buf);
|
||||
let line = line.trim_end_matches(['\n', '\r']).to_owned();
|
||||
if tx.send((kind, line)).is_err() {
|
||||
break;
|
||||
}
|
||||
let mut reader = BufReader::new(stream);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let line = ide_core::output_encoding::decode_tool_output(&buf);
|
||||
let line = line.trim_end_matches(['\n', '\r']).to_owned();
|
||||
if tx.send((kind, line)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -203,17 +102,7 @@ fn run_with_env_capture(
|
||||
child.stderr.take().map(|s| pump(Box::new(s), Stream::Stderr, tx.clone())),
|
||||
];
|
||||
drop(tx);
|
||||
// Retained copy of the output: the first half of the cap, then — once output overflows —
|
||||
// a rolling tail instead of the middle. Error summaries read the end of the output, while
|
||||
// listings parsed out of a successful run read from the start. The pipes keep draining
|
||||
// either way: `on_line` still sees every line, so the child never blocks on a full pipe.
|
||||
let cap = MAX_TEXT_BYTES / 2;
|
||||
let mut head = String::new();
|
||||
let mut tail: std::collections::VecDeque<Vec<u8>> = Default::default();
|
||||
let mut chunk: Vec<u8> = Vec::new();
|
||||
let mut tail_bytes = 0usize;
|
||||
let mut total = 0usize;
|
||||
let mut truncated = false;
|
||||
let mut text = String::new();
|
||||
loop {
|
||||
if cancel.is_cancelled() {
|
||||
kill_tree(&mut child);
|
||||
@@ -223,34 +112,8 @@ fn run_with_env_capture(
|
||||
Ok((_, line)) if encoding.notice.as_ref() == Some(&line) => {}
|
||||
Ok((stream, line)) => {
|
||||
on_line(stream, &line);
|
||||
if !bounded {
|
||||
// The caller parses a complete model from `text`, so keep every line.
|
||||
head.push_str(&line);
|
||||
head.push('\n');
|
||||
continue;
|
||||
}
|
||||
total += line.len() + 1;
|
||||
if !truncated {
|
||||
if head.len() + line.len() < cap {
|
||||
head.push_str(&line);
|
||||
head.push('\n');
|
||||
continue;
|
||||
}
|
||||
truncated = true;
|
||||
}
|
||||
// Fixed-size chunks, not per-line buffers: a chatty build pushes millions of
|
||||
// lines past the cap, and the tail must add no allocation per line.
|
||||
chunk.extend_from_slice(line.as_bytes());
|
||||
chunk.push(b'\n');
|
||||
if chunk.len() >= 64 * 1024 {
|
||||
tail_bytes += chunk.len();
|
||||
tail.push_back(std::mem::take(&mut chunk));
|
||||
chunk.reserve_exact(64 * 1024);
|
||||
while tail_bytes > cap {
|
||||
let Some(front) = tail.pop_front() else { break };
|
||||
tail_bytes -= front.len();
|
||||
}
|
||||
}
|
||||
text.push_str(&line);
|
||||
text.push('\n');
|
||||
}
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => {}
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
@@ -260,85 +123,13 @@ fn run_with_env_capture(
|
||||
let _ = r.join();
|
||||
}
|
||||
let status = child.wait()?;
|
||||
let mut text = head;
|
||||
if truncated {
|
||||
if !chunk.is_empty() {
|
||||
tail_bytes += chunk.len();
|
||||
tail.push_back(std::mem::take(&mut chunk));
|
||||
}
|
||||
// The last partial chunk may sit past the cap; drop whole front chunks back under it.
|
||||
while tail_bytes > cap {
|
||||
let Some(front) = tail.pop_front() else { break };
|
||||
tail_bytes -= front.len();
|
||||
}
|
||||
// Tail chunks are flushed only right after a completed line, so the tail always begins
|
||||
// at a line boundary — no leading fragment to drop.
|
||||
let tail = ide_core::output_encoding::decode_tool_output(&tail.into_iter().flatten().collect::<Vec<u8>>());
|
||||
let omitted = total.saturating_sub(text.len() + tail.len());
|
||||
if omitted == 0 {
|
||||
// Everything that overflowed the head still fits in the tail: nothing was lost.
|
||||
truncated = false;
|
||||
} else {
|
||||
text.push_str(&format!("[{omitted} bytes of build output between these lines were not retained]\n"));
|
||||
}
|
||||
text.push_str(&tail);
|
||||
}
|
||||
Ok(Output { success: status.success(), text, truncated })
|
||||
Ok(Output { success: status.success(), text })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_model_line_over_one_mebibyte_is_kept_whole_for_the_parsers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// A Gradle MODEL_LINE JSON line longer than the bounded pump's 1 MiB line cap,
|
||||
// surrounded by ordinary output.
|
||||
let script = "echo start; head -c 1048576 /dev/zero | tr '\\0' a; printf '\\n{\"id\":\"big\"}\\n'; echo end";
|
||||
let mut lines = Vec::new();
|
||||
let out = run(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, line| lines.push(line.to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// The long line is one line, not segments that a JSON-line parser would skip.
|
||||
assert_eq!(lines.len(), 4);
|
||||
assert_eq!(lines[1].len(), 1_048_576);
|
||||
assert!(out.text.contains("{\"id\":\"big\"}"));
|
||||
let models: Vec<serde_json::Value> = out.text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
|
||||
assert_eq!(models.len(), 1, "the model line must survive full retention");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_successful_report_over_the_text_cap_is_retained_in_full() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
|
||||
let mut fed = 0usize;
|
||||
let out = run("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// Every line of a large successful dependency/model report is still there.
|
||||
assert_eq!(out.text.len(), fed);
|
||||
assert!(out.text.starts_with("1\n"));
|
||||
assert!(out.text.ends_with("6000000\n"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_and_cancels_processes() {
|
||||
if cfg!(windows) {
|
||||
@@ -357,11 +148,10 @@ mod tests {
|
||||
)
|
||||
.unwrap();
|
||||
assert!(!out.success);
|
||||
assert!(!out.truncated);
|
||||
lines.sort_by(|a, b| a.1.cmp(&b.1));
|
||||
assert_eq!(lines, [(Stream::Stdout, "one".to_owned()), (Stream::Stderr, "two".to_owned())]);
|
||||
cancel.cancel();
|
||||
let err = run_bounded("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
let err = run("sh", &["-c".into(), "sleep 5".into()], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {})
|
||||
.err()
|
||||
.unwrap();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
@@ -381,117 +171,9 @@ mod tests {
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
c.cancel();
|
||||
});
|
||||
let err =
|
||||
run_bounded("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
|
||||
let err = run("sh", &["-c".into(), script], tmp.path(), &BTreeMap::new(), &cancel, |_, _| {}).err().unwrap();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
std::thread::sleep(Duration::from_millis(1300));
|
||||
assert!(!marker.exists(), "the background child must be killed with the group");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_past_the_text_cap_keeps_head_and_tail_and_drains() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// Numbered lines 1..=6,000,000 ≈ 45 MB: past the 32 MiB retained cap.
|
||||
let args = ["-c".into(), r"awk 'BEGIN{for(i=1;i<=6000000;i++)print i}'".into()];
|
||||
let mut fed = 0usize;
|
||||
let mut last_seen = String::new();
|
||||
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
fed += line.len() + 1;
|
||||
last_seen = line.to_owned();
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(out.truncated);
|
||||
// The pipes drained to the end: the callback saw the last line.
|
||||
assert_eq!(last_seen, "6000000");
|
||||
assert_eq!(fed, out_success_bytes());
|
||||
// The retained copy is bounded, keeps the head and the tail, and says what was dropped.
|
||||
assert!(out.text.len() <= MAX_TEXT_BYTES + 128, "{}", out.text.len());
|
||||
assert!(out.text.starts_with("1\n"));
|
||||
assert!(out.text.ends_with("6000000\n"));
|
||||
assert!(out.text.contains("were not retained]"));
|
||||
assert!(!out.text.contains("\n3000000\n"), "a middle line must be the dropped part");
|
||||
}
|
||||
|
||||
/// Lines `1..=6_000_000` emit exactly this many bytes (digit count + newline each).
|
||||
fn out_success_bytes() -> usize {
|
||||
(1..=6_000_000u64).map(|n| n.checked_ilog10().unwrap() as usize + 2).sum()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_newline_free_run_longer_than_the_line_cap_arrives_as_split_lines() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// 2.5 MiB of `x` without a single newline.
|
||||
let args = ["-c".into(), "head -c 2621440 /dev/zero | tr '\\0' x".into()];
|
||||
let mut lines = Vec::new();
|
||||
let out = run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines.push(line.to_owned())
|
||||
})
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
// Split at the cap, not dropped: the segments carry every byte and none is unbounded.
|
||||
assert!(lines.len() >= 3, "{}", lines.len());
|
||||
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 2_621_440);
|
||||
assert!(lines.iter().all(|l| l.len() <= MAX_LINE_BYTES));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_line_split_never_cuts_a_multibyte_character() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// `x` up to one byte before the 1 MiB cap, then `é` (two bytes) straddling it, then more `x`.
|
||||
let script =
|
||||
"head -c 1048575 /dev/zero | tr '\\0' x; printf '\\303\\251'; head -c 1048575 /dev/zero | tr '\\0' x";
|
||||
let mut lines = Vec::new();
|
||||
let out = run_bounded(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, line| lines.push(line.to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
// The é straddles the 1 MiB split point: segments shift to keep it whole.
|
||||
assert!(lines.len() >= 2, "{}", lines.len());
|
||||
// The character survived the split: present whole, never as U+FFFD halves.
|
||||
assert!(lines.iter().any(|l| l.contains('é')));
|
||||
assert!(lines.iter().all(|l| !l.contains('\u{FFFD}')));
|
||||
assert_eq!(lines.iter().map(String::len).sum::<usize>(), 1_048_575 + 2 + 1_048_575);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_just_past_the_head_cap_loses_nothing() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
// 4-byte `pad` lines up to just past the 16 MiB head cap, then the real last line:
|
||||
// the overflow fits the tail whole, so nothing is dropped and nothing is marked.
|
||||
let script = "yes pad | head -c 16777213; echo 'FATAL: the real error'";
|
||||
let out = run_bounded(
|
||||
"sh",
|
||||
&["-c".into(), script.into()],
|
||||
tmp.path(),
|
||||
&BTreeMap::new(),
|
||||
&CancellationToken::new(),
|
||||
|_, _| {},
|
||||
)
|
||||
.unwrap();
|
||||
assert!(out.success);
|
||||
assert!(!out.truncated);
|
||||
assert!(!out.text.contains("were not retained]"));
|
||||
assert!(out.text.starts_with("pad\n"));
|
||||
assert!(out.text.ends_with("FATAL: the real error\n"));
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//! Timed evidence for the bounded build-output capture (issue #3936). Not an assertion:
|
||||
//! run it on both revisions of `process.rs` and compare the printed numbers.
|
||||
//!
|
||||
//! ```text
|
||||
//! cargo test -p ide-build --release --lib -- --ignored --nocapture numbers
|
||||
//! ```
|
||||
|
||||
use crate::process;
|
||||
use ide_core::CancellationToken;
|
||||
use std::collections::BTreeMap;
|
||||
use std::time::Instant;
|
||||
|
||||
/// 256 MiB of 17-byte lines from `yes`, drained by `process::run` with a counting callback.
|
||||
#[test]
|
||||
#[ignore = "prints elapsed time and retained bytes; see the module docs"]
|
||||
fn high_output_process_numbers() {
|
||||
if cfg!(windows) {
|
||||
return;
|
||||
}
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let args = ["-c".into(), "yes 0123456789abcdef | head -c 268435456".into()];
|
||||
let start = Instant::now();
|
||||
let mut lines = 0u64;
|
||||
let mut fed = 0usize;
|
||||
let out = process::run_bounded("sh", &args, tmp.path(), &BTreeMap::new(), &CancellationToken::new(), |_, line| {
|
||||
lines += 1;
|
||||
fed += line.len() + 1;
|
||||
})
|
||||
.unwrap();
|
||||
println!(
|
||||
"elapsed {:?} | success {} | retained {} bytes | fed {lines} lines / {fed} bytes",
|
||||
start.elapsed(),
|
||||
out.success,
|
||||
out.text.len()
|
||||
);
|
||||
}
|
||||
@@ -268,20 +268,8 @@ fn run(
|
||||
process::run(program, args, cwd, env, cancel, |_, line| on_line(line))
|
||||
}
|
||||
|
||||
/// What a sync records when a *successful* child run's output was truncated: parsing a
|
||||
/// truncated listing would silently produce an incomplete model, so it is surfaced, not hidden.
|
||||
pub(crate) fn truncation_note(out: &Output) -> Option<String> {
|
||||
out.truncated.then(|| {
|
||||
format!(
|
||||
"the build printed more than the retained {} MiB of output; the model may be incomplete",
|
||||
crate::process::MAX_TEXT_BYTES / (1024 * 1024)
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// The first error lines of a failed build, for the tool window.
|
||||
pub(crate) fn error_summary(output: &Output) -> String {
|
||||
let text = &output.text;
|
||||
pub(crate) fn error_summary(text: &str) -> String {
|
||||
// The JVM's "could not find or load main class" (localized) when `gradlew` has no jar.
|
||||
if text.contains("org.gradle.wrapper.GradleWrapperMain") {
|
||||
return "gradle/wrapper/gradle-wrapper.jar is missing (often excluded by a `*.jar` rule in .gitignore). \
|
||||
@@ -301,15 +289,11 @@ pub(crate) fn error_summary(output: &Output) -> String {
|
||||
.filter(|l| !l.is_empty() && !l.starts_with("Re-run Maven") && !l.starts_with("To see the full stack trace"))
|
||||
.take(4)
|
||||
.collect();
|
||||
let mut summary = if lines.is_empty() {
|
||||
if lines.is_empty() {
|
||||
text.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("the build failed").trim().to_owned()
|
||||
} else {
|
||||
lines.join("\n")
|
||||
};
|
||||
if output.truncated {
|
||||
summary.push_str("\n[the build printed more than the retained output; this summary may miss lines]");
|
||||
}
|
||||
summary
|
||||
}
|
||||
|
||||
/// `[INFO] Building core 1.0-SNAPSHOT [2/3]` → ("core 1.0-SNAPSHOT", 2, 3).
|
||||
@@ -413,9 +397,7 @@ pub fn sync_maven(
|
||||
}
|
||||
}
|
||||
if !out.success {
|
||||
errors.push(error_summary(&out));
|
||||
} else if let Some(note) = truncation_note(&out) {
|
||||
errors.push(note);
|
||||
errors.push(error_summary(&out.text));
|
||||
}
|
||||
}
|
||||
cache.at_ms = now_ms();
|
||||
@@ -455,8 +437,6 @@ pub fn sync_gradle_model(
|
||||
let mut args: Vec<String> = vec![
|
||||
"--console=plain".into(),
|
||||
"-q".into(),
|
||||
// The init script reports the evaluated projects, even when a build enables the configuration cache.
|
||||
"-Dorg.gradle.configuration-cache=false".into(),
|
||||
"--init-script".into(),
|
||||
init_script.to_string_lossy().into_owned(),
|
||||
"tasks".into(),
|
||||
@@ -477,7 +457,7 @@ pub fn sync_gradle_model(
|
||||
Ok(out) => out,
|
||||
Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
|
||||
Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
|
||||
Output { success: false, text: error.message, truncated: false }
|
||||
Output { success: false, text: error.message }
|
||||
}
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
@@ -490,7 +470,7 @@ pub fn sync_gradle_model(
|
||||
let cache = GradleCache {
|
||||
hash: hash_gradle_files(&gradle::build_files(root, &model)),
|
||||
at_ms: now_ms(),
|
||||
error: if !out.success { Some(error_summary(&out)) } else { truncation_note(&out) },
|
||||
error: (!out.success).then(|| error_summary(&out.text)),
|
||||
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
|
||||
projects,
|
||||
resources: true,
|
||||
@@ -934,22 +914,10 @@ mod tests {
|
||||
);
|
||||
assert_eq!(maven_building("[INFO] Building jar: x.jar"), None);
|
||||
let text = "[INFO] x\n[ERROR] Failed to execute goal\n[ERROR] \n[ERROR] Re-run Maven using -X\n";
|
||||
let out = |text: &str, truncated| crate::process::Output { success: false, text: text.to_owned(), truncated };
|
||||
assert_eq!(error_summary(&out(text, false)), "Failed to execute goal");
|
||||
assert_eq!(error_summary(&out("one\nlast line\n\n", false)), "last line");
|
||||
assert_eq!(error_summary(text), "Failed to execute goal");
|
||||
assert_eq!(error_summary("one\nlast line\n\n"), "last line");
|
||||
let missing_jar = "错误: 找不到或无法加载主类 org.gradle.wrapper.GradleWrapperMain\n";
|
||||
assert!(error_summary(&out(missing_jar, false)).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
// A truncated capture says so instead of hiding that lines are missing.
|
||||
assert!(error_summary(&out(text, true)).ends_with("this summary may miss lines]"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_successful_run_is_surfaced_not_silent() {
|
||||
let out = |truncated| crate::process::Output { success: true, text: String::new(), truncated };
|
||||
assert!(truncation_note(&out(false)).is_none());
|
||||
let note = truncation_note(&out(true)).unwrap();
|
||||
assert!(note.starts_with("the build printed more than the retained 32 MiB"), "{note}");
|
||||
assert!(note.ends_with("the model may be incomplete"));
|
||||
assert!(error_summary(missing_jar).starts_with("gradle/wrapper/gradle-wrapper.jar is missing"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -446,12 +446,6 @@ pub struct LanguageCodeStyle {
|
||||
/// Comment Code › Add a space at line comment start.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub line_comment_add_space: Option<bool>,
|
||||
/// PHP: align `=>` in multi-line arrays after formatting (other languages ignore it).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub align_key_value_pairs: Option<bool>,
|
||||
/// PHP: align `=` of consecutive assignment statements after formatting.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub align_consecutive_assignments: Option<bool>,
|
||||
}
|
||||
|
||||
/// Editor › Code Style (General tab + per-language overrides).
|
||||
|
||||
@@ -53,10 +53,6 @@ pub enum IdeEvent {
|
||||
root: crate::IpcPath,
|
||||
status: DirenvStatus,
|
||||
},
|
||||
/// The project's `flutter daemon` changed state, or a device came or went.
|
||||
FlutterDevices {
|
||||
list: FlutterDeviceList,
|
||||
},
|
||||
/// Files or directories changed on disk (after debouncing, ignore rules applied).
|
||||
FsChanged {
|
||||
created: Vec<crate::IpcPath>,
|
||||
@@ -238,46 +234,6 @@ pub enum AskpassKind {
|
||||
Confirm,
|
||||
}
|
||||
|
||||
/// A target `flutter run -d <id>` can name, or an Android device adb sees but Flutter can't use yet.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct FlutterDevice {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
/// `android`, `ios`, `macos`, `web`, …
|
||||
pub platform_type: Option<String>,
|
||||
/// `mobile`, `desktop` or `web`.
|
||||
pub category: Option<String>,
|
||||
pub emulator: bool,
|
||||
/// The adb state keeping it from being used (`unauthorized`, `offline`, …).
|
||||
pub unavailable: Option<String>,
|
||||
}
|
||||
|
||||
/// See [`FlutterDeviceList`].
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum FlutterDaemonStatus {
|
||||
#[default]
|
||||
Stopped,
|
||||
/// Started; the first device discovery has not finished.
|
||||
Starting,
|
||||
Ready,
|
||||
/// No `flutter` executable on the search path.
|
||||
NotInstalled,
|
||||
/// The daemon could not start or exited: what it printed last. It is not restarted on its own.
|
||||
Failed {
|
||||
message: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// The project's Flutter devices, best default first.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct FlutterDeviceList {
|
||||
pub status: FlutterDaemonStatus,
|
||||
pub devices: Vec<FlutterDevice>,
|
||||
}
|
||||
|
||||
/// See [`IdeEvent::Direnv`].
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
@@ -367,9 +323,6 @@ pub enum DebugEvent {
|
||||
change_type: String,
|
||||
message: String,
|
||||
},
|
||||
/// `flutter debug_adapter`'s `flutter.appStarted` event (launch and attach): the session is
|
||||
/// a Flutter app that can take a hot reload now. The plain Dart adapter never sends it.
|
||||
FlutterAppStarted,
|
||||
/// The session's capabilities changed after it started: fetch them again.
|
||||
Capabilities,
|
||||
/// The adapter's `invalidated` event: what it shows for `areas` (`all`, `stacks`, `threads`,
|
||||
|
||||
@@ -16,55 +16,18 @@ pub const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
/// For a `tokio::process::Command`, pass `cmd.as_std_mut()`.
|
||||
///
|
||||
/// - Windows: release builds use the GUI subsystem, so without `CREATE_NO_WINDOW` every
|
||||
/// console child flashes a `cmd` window. Batch files also need a PATH small enough for cmd.
|
||||
/// console child flashes a `cmd` window.
|
||||
/// - Linux AppImage, reloaded and project variables: see [`host_env`].
|
||||
///
|
||||
/// Explicit variables take precedence over the host environment. Call after setting
|
||||
/// `current_dir` and any explicit `PATH`, and before `env_clear`.
|
||||
/// Variables the call site has already set are kept; call it before `env_clear` and after
|
||||
/// `current_dir`, which picks the project environment.
|
||||
pub fn prepare(cmd: &mut Command) -> &mut Command {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
cmd.creation_flags(CREATE_NO_WINDOW);
|
||||
}
|
||||
host_env(cmd);
|
||||
#[cfg(windows)]
|
||||
compact_batch_path(cmd);
|
||||
cmd
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn compact_batch_path(cmd: &mut Command) {
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::{Component, Prefix};
|
||||
|
||||
// Rust runs these files through cmd.exe, which drops inherited variables over this limit.
|
||||
const CMD_ENV_LIMIT: usize = 8191;
|
||||
let extension = Path::new(cmd.get_program()).extension();
|
||||
if !extension.is_some_and(|ext| ext.eq_ignore_ascii_case("cmd") || ext.eq_ignore_ascii_case("bat")) {
|
||||
return;
|
||||
}
|
||||
let path = match cmd.get_envs().find(|(key, _)| key.eq_ignore_ascii_case("PATH")) {
|
||||
Some((_, path)) => path.map(OsStr::to_owned),
|
||||
None => std::env::var_os("PATH"),
|
||||
};
|
||||
let Some(path) = path.filter(|p| p.encode_wide().count() > CMD_ENV_LIMIT) else { return };
|
||||
|
||||
// The IDE includes possible locations of as-yet uninstalled tools. Prune paths that are
|
||||
// missing now, keeping search precedence and leaving UNC and relative paths alone.
|
||||
let dirs = std::env::split_paths(&path).filter(|dir| {
|
||||
let local = dir.is_absolute()
|
||||
&& matches!(dir.components().next(), Some(Component::Prefix(p))
|
||||
if matches!(p.kind(), Prefix::Disk(_) | Prefix::VerbatimDisk(_)));
|
||||
!local
|
||||
|| !std::fs::symlink_metadata(dir)
|
||||
.is_err_and(|e| matches!(e.kind(), std::io::ErrorKind::NotFound | std::io::ErrorKind::NotADirectory))
|
||||
});
|
||||
if let Ok(compact) = std::env::join_paths(dirs)
|
||||
&& compact.encode_wide().count() <= CMD_ENV_LIMIT
|
||||
{
|
||||
cmd.env("PATH", compact);
|
||||
}
|
||||
host_env(cmd)
|
||||
}
|
||||
|
||||
/// Starts the child as the leader of its own process group on Unix, so [`kill_tree`] and
|
||||
@@ -922,44 +885,6 @@ mod tests {
|
||||
assert!(!process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn batch_launch_keeps_runtime_paths_when_cmd_would_drop_path() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
let script = root.path().join("server.CMD");
|
||||
std::fs::write(&script, "@echo off\r\nif not defined PATH exit /b 42\r\n").unwrap();
|
||||
let selected = root.path().join("Selected Runtime");
|
||||
let fallback = root.path().join("Fallback Runtime");
|
||||
std::fs::create_dir(&selected).unwrap();
|
||||
std::fs::create_dir(&fallback).unwrap();
|
||||
let relative = Path::new("relative");
|
||||
let unc = Path::new(r"\\openidea-test\share\bin");
|
||||
let missing = root.path().join("uninstalled-".repeat(12));
|
||||
let path = std::env::join_paths(
|
||||
std::iter::once(selected.as_path()).chain(std::iter::repeat_n(missing.as_path(), 60)).chain([
|
||||
unc,
|
||||
relative,
|
||||
fallback.as_path(),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
let compact = std::env::join_paths([selected.as_path(), unc, relative, fallback.as_path()]).unwrap();
|
||||
|
||||
let path_in = |cmd: &Command| {
|
||||
cmd.get_envs()
|
||||
.find_map(|(key, value)| key.eq_ignore_ascii_case("PATH").then(|| value.map(OsStr::to_owned)))
|
||||
.flatten()
|
||||
};
|
||||
let mut cmd = Command::new(&script);
|
||||
cmd.current_dir(root.path()).env("PATH", &path);
|
||||
prepare(&mut cmd);
|
||||
assert_eq!(path_in(&cmd), Some(compact));
|
||||
assert!(cmd.status().unwrap().success());
|
||||
|
||||
let mut native = Command::new(root.path().join("server.exe"));
|
||||
assert_eq!(path_in(prepare(native.env("PATH", &path))), Some(path));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn process_alive_rejects_ids_that_are_not_a_single_process() {
|
||||
|
||||
@@ -50,8 +50,6 @@ pub struct Settings {
|
||||
/// Per language server, by name (`rust-analyzer`): launch and protocol
|
||||
/// options on top of the language definition, or a server defined here.
|
||||
pub language_servers: BTreeMap<String, LanguageServerSettings>,
|
||||
/// Tools › Download sources: a mirror prefix for the release archives the installer fetches.
|
||||
pub tool_downloads: ToolDownloadSettings,
|
||||
/// Editor › Inspections profiles.
|
||||
pub inspections: InspectionSettings,
|
||||
/// Editor › Natural Languages › Spelling.
|
||||
@@ -363,22 +361,6 @@ impl Default for McpServerSettings {
|
||||
}
|
||||
}
|
||||
|
||||
/// Tools › Download sources: a mirror the installer tries when `github.com` is slow or
|
||||
/// unreachable.
|
||||
///
|
||||
/// The mirror is a proxy prefix: the official URL is appended to it unchanged
|
||||
/// (`https://mirror.example/https://github.com/o/r/releases/download/…`), which is what the
|
||||
/// public GitHub proxies speak. Only `github.com` downloads are affected — those proxies
|
||||
/// hard-code that host, so Eclipse JDT LS and Open VSX keep their official addresses. Empty by
|
||||
/// default, so every download stays on its official host until the user opts in.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct ToolDownloadSettings {
|
||||
/// Proxy prefix prepended to `https://github.com/…` archive addresses only; empty keeps
|
||||
/// every download on its official host.
|
||||
pub github_mirror: String,
|
||||
}
|
||||
|
||||
/// Absent profiles retain automatic discovery for existing projects.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -517,7 +499,6 @@ impl Default for Settings {
|
||||
external_tools: Vec::new(),
|
||||
tools: BTreeMap::new(),
|
||||
language_servers: BTreeMap::new(),
|
||||
tool_downloads: ToolDownloadSettings::default(),
|
||||
inspections: InspectionSettings::default(),
|
||||
spelling: SpellingSettings::default(),
|
||||
ssh: SshSettings::default(),
|
||||
@@ -771,8 +752,6 @@ pub struct AppearanceSettings {
|
||||
pub compact_mode: bool,
|
||||
/// IDEA "Use smaller indents in trees": tool window trees indent less per level.
|
||||
pub small_tree_indents: bool,
|
||||
/// Linux: WebKit animates each mouse wheel step
|
||||
pub smooth_scrolling: bool,
|
||||
pub full_path_in_title: bool,
|
||||
pub project_colors_in_toolbar: bool,
|
||||
pub dnd_with_alt_only: bool,
|
||||
@@ -791,8 +770,6 @@ pub struct AppearanceSettings {
|
||||
pub show_tool_window_names: bool,
|
||||
pub show_tool_window_badges: bool,
|
||||
pub widescreen_tool_windows: bool,
|
||||
/// Each tool window keeps its own size; off, the windows of a side share one.
|
||||
pub remember_tool_window_sizes: bool,
|
||||
/// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
|
||||
pub show_main_toolbar: bool,
|
||||
pub show_status_bar: bool,
|
||||
@@ -908,7 +885,6 @@ impl Default for AppearanceSettings {
|
||||
different_tool_window_background: false,
|
||||
compact_mode: false,
|
||||
small_tree_indents: false,
|
||||
smooth_scrolling: true,
|
||||
full_path_in_title: false,
|
||||
project_colors_in_toolbar: true,
|
||||
dnd_with_alt_only: false,
|
||||
@@ -922,7 +898,6 @@ impl Default for AppearanceSettings {
|
||||
show_tool_window_names: false,
|
||||
show_tool_window_badges: true,
|
||||
widescreen_tool_windows: false,
|
||||
remember_tool_window_sizes: false,
|
||||
show_main_toolbar: true,
|
||||
show_status_bar: true,
|
||||
navigation_bar: NavigationBarPosition::StatusBar,
|
||||
@@ -1403,8 +1378,6 @@ pub struct GoSettings {
|
||||
pub goroot: String,
|
||||
/// Empty = `go env GOPATH`.
|
||||
pub gopath: String,
|
||||
/// Format with gofumpt, a stricter gofmt (gopls `gofumpt`).
|
||||
pub gofumpt: bool,
|
||||
pub build_tags: GoBuildTags,
|
||||
pub modules: GoModules,
|
||||
}
|
||||
@@ -1531,10 +1504,6 @@ pub struct MavenSettings {
|
||||
pub active_profiles: String,
|
||||
/// Delegate IDE build/run actions to Maven: launches build with Maven (`javac`) instead of jdtls (ECJ).
|
||||
pub delegate_build: bool,
|
||||
/// Download `-sources.jar` of dependencies when the Java language server imports the
|
||||
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
|
||||
/// from a library class's Download Sources banner.
|
||||
pub download_sources: bool,
|
||||
}
|
||||
|
||||
impl MavenSettings {
|
||||
@@ -1779,16 +1748,6 @@ mod tests {
|
||||
assert_eq!(kept.appearance.theme, "solarized-dark");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn smooth_scrolling_defaults_on_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"appearance":{"zoom":110}}"#).unwrap();
|
||||
assert!(old.appearance.smooth_scrolling);
|
||||
let off: Settings = serde_json::from_str(r#"{"appearance":{"smoothScrolling":false}}"#).unwrap();
|
||||
assert!(!off.appearance.smooth_scrolling);
|
||||
let json = serde_json::to_value(&off).unwrap();
|
||||
assert_eq!(json["appearance"]["smoothScrolling"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn window_close_settings_default_off_and_round_trip() {
|
||||
for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
|
||||
|
||||
@@ -20,34 +20,6 @@ pub struct VcsSettings {
|
||||
pub shelf: ShelfSettings,
|
||||
/// Issue Navigation: commit-message patterns turned into links.
|
||||
pub issue_navigation: Vec<IssueLink>,
|
||||
/// Directory Mappings: repository roots added to or excluded from the detected ones.
|
||||
pub mappings: VcsMappings,
|
||||
}
|
||||
|
||||
/// Directory Mappings on top of repository detection. Paths are relative to the project
|
||||
/// root (`.` for the root itself) or absolute outside it.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct VcsMappings {
|
||||
/// Detected repositories the IDE leaves alone: no Git or Commit integration, files stay.
|
||||
pub excluded: Vec<String>,
|
||||
/// Repository roots detection does not reach (outside the project, or deeper).
|
||||
pub added: Vec<String>,
|
||||
}
|
||||
|
||||
impl VcsMappings {
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.excluded.is_empty() && self.added.is_empty()
|
||||
}
|
||||
|
||||
/// `path` resolved against `project_root`.
|
||||
pub fn resolve(project_root: &std::path::Path, path: &str) -> std::path::PathBuf {
|
||||
match path {
|
||||
"" | "." => project_root.to_path_buf(),
|
||||
p if std::path::Path::new(p).is_absolute() => p.into(),
|
||||
p => project_root.join(p),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for VcsSettings {
|
||||
@@ -62,7 +34,6 @@ impl Default for VcsSettings {
|
||||
confirmation: VcsConfirmationSettings::default(),
|
||||
shelf: ShelfSettings::default(),
|
||||
issue_navigation: Vec::new(),
|
||||
mappings: VcsMappings::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -106,9 +77,6 @@ pub struct GitSettings {
|
||||
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
/// stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
pub staging_area: bool,
|
||||
/// Scan the working tree with `git status` (for file systems whose metadata only
|
||||
/// the system git reads correctly) instead of in process.
|
||||
pub cli_status: bool,
|
||||
}
|
||||
|
||||
impl Default for GitSettings {
|
||||
@@ -133,7 +101,6 @@ impl Default for GitSettings {
|
||||
push_dialog_only_protected: false,
|
||||
combine_stash_and_shelf: false,
|
||||
staging_area: false,
|
||||
cli_status: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -367,8 +334,6 @@ pub struct DebuggerSettings {
|
||||
pub skip_library_code: bool,
|
||||
/// JavaScript: debugging a dev server (`vite`, `next dev`) also opens its page in a browser session.
|
||||
pub debug_server_page: bool,
|
||||
/// Flutter: saving a Dart file of a running debug session hot reloads the app.
|
||||
pub flutter_hot_reload_on_save: bool,
|
||||
pub python: PythonDebuggerSettings,
|
||||
}
|
||||
|
||||
@@ -389,7 +354,6 @@ impl Default for DebuggerSettings {
|
||||
value_tooltip_delay: 700,
|
||||
skip_library_code: true,
|
||||
debug_server_page: false,
|
||||
flutter_hot_reload_on_save: true,
|
||||
python: PythonDebuggerSettings::default(),
|
||||
}
|
||||
}
|
||||
@@ -463,8 +427,6 @@ pub struct TerminalSettings {
|
||||
/// `block` | `underline` | `bar`.
|
||||
pub cursor_shape: String,
|
||||
pub cursor_blink: bool,
|
||||
/// Cap PTY→xterm paint rate: `unlimited` | `60` | `30` | `15` | `10`.
|
||||
pub max_fps: String,
|
||||
pub use_editor_font: bool,
|
||||
pub font_family: String,
|
||||
pub font_size: f32,
|
||||
@@ -496,7 +458,6 @@ impl Default for TerminalSettings {
|
||||
escape_to_editor: false,
|
||||
cursor_shape: "block".into(),
|
||||
cursor_blink: true,
|
||||
max_fps: "unlimited".into(),
|
||||
use_editor_font: true,
|
||||
font_family: "JetBrains Mono".into(),
|
||||
font_size: 13.0,
|
||||
|
||||
@@ -22,8 +22,6 @@ use tokio::process::{Child, Command};
|
||||
pub const PORT_PLACEHOLDER: &str = "${port}";
|
||||
/// Replaced by the session's working directory (the project) in adapter arguments.
|
||||
pub const ROOT_PLACEHOLDER: &str = "${root}";
|
||||
/// java-analyzer's debug adapter (`java-analyzer dap`), a separate process over stdio.
|
||||
pub const JAVA_ANALYZER: &str = "java-analyzer";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum Transport {
|
||||
@@ -136,14 +134,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
"tcp",
|
||||
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
|
||||
),
|
||||
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
|
||||
// runs the executable of the java-analyzer serving the module.
|
||||
JAVA_ANALYZER => cfg(
|
||||
"java-analyzer",
|
||||
&["dap"],
|
||||
"stdio",
|
||||
"Configure java-analyzer as a Java language server (Settings › Languages & Frameworks › Language Servers)",
|
||||
),
|
||||
"bun-dap" => cfg(
|
||||
"bun-dap",
|
||||
&["${port}", "127.0.0.1"],
|
||||
@@ -930,13 +920,6 @@ mod tests {
|
||||
}
|
||||
let delve = resolve(&builtin("delve").unwrap(), PathBuf::from("/"));
|
||||
assert_eq!(delve.transport, Transport::Tcp);
|
||||
// java-analyzer debugs over stdio with its `dap` subcommand.
|
||||
let java_analyzer = resolve(&builtin(JAVA_ANALYZER).unwrap(), PathBuf::from("/"));
|
||||
assert_eq!(
|
||||
(java_analyzer.command.as_str(), java_analyzer.args.as_slice()),
|
||||
("java-analyzer", &["dap".to_owned()][..])
|
||||
);
|
||||
assert_eq!(java_analyzer.transport, Transport::Stdio);
|
||||
// GDB's own DAP interpreter over stdio, with the required version in its hint.
|
||||
let gdb = builtin("gdb").unwrap();
|
||||
assert_eq!(gdb.command, "gdb");
|
||||
|
||||
@@ -280,14 +280,6 @@ pub struct SessionExceptionFilters {
|
||||
pub filters: Vec<ExceptionFilter>,
|
||||
}
|
||||
|
||||
/// What triggered a hot reload; `flutter debug_adapter` takes it as `reason`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum HotReloadReason {
|
||||
Manual,
|
||||
Save,
|
||||
}
|
||||
|
||||
/// A live session, as listed by [`DebugManager::sessions`].
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -412,14 +404,6 @@ fn is_flutter_project(dir: &Path, program: Option<&Path>) -> bool {
|
||||
.any(|s| s.contains("sdk: flutter"))
|
||||
}
|
||||
|
||||
/// `flutter debug_adapter` passes `toolArgs` on to `flutter run` / `flutter attach`.
|
||||
fn add_flutter_device(arguments: &mut Value, device: Value) {
|
||||
let args = arguments.as_object_mut().map(|o| o.entry("toolArgs").or_insert_with(|| json!([])));
|
||||
if let Some(args) = args.and_then(Value::as_array_mut) {
|
||||
args.extend([json!("-d"), device]);
|
||||
}
|
||||
}
|
||||
|
||||
fn no_session(s: DebugSessionId) -> IdeError {
|
||||
IdeError::not_found(format!("no debug session {}", s.0))
|
||||
}
|
||||
@@ -784,8 +768,6 @@ impl DebugManager {
|
||||
// one regardless of what the working directory holds.
|
||||
let force_flutter =
|
||||
arguments.as_object_mut().and_then(|o| o.remove("__flutter")).and_then(|v| v.as_bool()).unwrap_or(false);
|
||||
// Also IDE-side: the device to run on, should this turn out to be a Flutter session.
|
||||
let flutter_device = arguments.as_object_mut().and_then(|o| o.remove("__flutterDevice"));
|
||||
let cwd = config
|
||||
.cwd
|
||||
.clone()
|
||||
@@ -830,15 +812,10 @@ impl DebugManager {
|
||||
// Flutter: a project depending on the Flutter SDK needs `flutter debug_adapter`
|
||||
// (the Dart adapter cannot start a program importing `dart:ui`, and hot reload
|
||||
// is Flutter-only). Plain Dart projects keep the configured `dart`.
|
||||
if config.adapter == "dart" {
|
||||
if config.adapter == "dart" && spec.command == "dart" {
|
||||
let program = arguments.get("program").and_then(Value::as_str).map(Path::new);
|
||||
if force_flutter || is_flutter_project(&cwd, program) {
|
||||
if spec.command == "dart" {
|
||||
spec.command = "flutter".into();
|
||||
}
|
||||
if let Some(device) = flutter_device {
|
||||
add_flutter_device(&mut arguments, device);
|
||||
}
|
||||
spec.command = "flutter".into();
|
||||
}
|
||||
}
|
||||
let id = DebugSessionId::next();
|
||||
@@ -1669,8 +1646,8 @@ impl DebugManager {
|
||||
|
||||
/// Flutter's DAP adapter: injects the changed sources into the running app.
|
||||
/// Not part of the DAP standard; adapters that do not know the request reject it.
|
||||
pub async fn hot_reload(&self, s: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
|
||||
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": reason }), REQUEST_TIMEOUT).await?;
|
||||
pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {
|
||||
self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -504,9 +504,6 @@ impl Session {
|
||||
|
||||
/// How long Stop waits for a launched program to exit before reporting the session ended.
|
||||
pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);
|
||||
/// How long a stop waits for a killed program to be gone (Windows ends processes asynchronously).
|
||||
#[cfg(windows)]
|
||||
const DEBUGGEE_KILL_WAIT: Duration = Duration::from_secs(5);
|
||||
|
||||
pub(crate) async fn remember_debuggee(s: &Arc<Session>) {
|
||||
#[cfg(windows)]
|
||||
@@ -646,24 +643,14 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
|
||||
}
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::time::Instant;
|
||||
remember_debuggee(s).await;
|
||||
let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
|
||||
let mut killed: Option<Instant> = None;
|
||||
let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
|
||||
// The captured tree is the oracle when it was captured; otherwise the job (every
|
||||
// process the launch started) is, so a failed capture can no longer end the wait
|
||||
// while the program still holds its port.
|
||||
while launch_running(s) {
|
||||
let now = Instant::now();
|
||||
if s.stop_force.swap(false, Ordering::AcqRel) || (killed.is_none() && now >= deadline) {
|
||||
if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
|
||||
signal_debuggee(s, true).await;
|
||||
killed.get_or_insert(now);
|
||||
}
|
||||
// Termination is asynchronous, and a process TerminateProcess can't end (stuck in
|
||||
// the kernel) would hold the stop forever: give up on it, as on Unix.
|
||||
if killed.is_some_and(|at| now.duration_since(at) >= DEBUGGEE_KILL_WAIT) {
|
||||
tracing::warn!(session = s.id.0, pid, "stop: the debugged program did not exit after it was killed");
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
@@ -879,7 +866,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
change_type: crate::hot_code_replace_type(body.get("changeType")),
|
||||
message: str_("message").unwrap_or_default(),
|
||||
}),
|
||||
"flutter.appStarted" => s.emit(DebugEvent::FlutterAppStarted),
|
||||
// Sent only by adapters told `supportsInvalidatedEvent` (kotlin-lsp).
|
||||
"invalidated" => s.emit(DebugEvent::Invalidated {
|
||||
areas: body
|
||||
@@ -926,7 +912,7 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
|
||||
|
||||
/// A `runInTerminal` program and the pseudo-terminal it runs in.
|
||||
pub(crate) struct ProgramTerminal {
|
||||
writer: Arc<ide_core::input::InputWriter>,
|
||||
writer: ide_core::input::InputWriter,
|
||||
killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
|
||||
#[cfg_attr(not(unix), allow(dead_code))]
|
||||
pid: Option<u32>,
|
||||
@@ -1039,12 +1025,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
let _ = child.wait();
|
||||
})
|
||||
.map_err(|e| format!("terminal input worker: {e}"))?;
|
||||
let writer = Arc::new(writer);
|
||||
let pid = child.process_id();
|
||||
forward_terminal_output(
|
||||
s,
|
||||
reader,
|
||||
writer.clone(),
|
||||
#[cfg(unix)]
|
||||
wait_readable,
|
||||
);
|
||||
@@ -1059,35 +1043,10 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
|
||||
Ok(json!({ "processId": pid }))
|
||||
}
|
||||
|
||||
/// A terminal's cursor position query (DSR). ConPTY sends one when it starts and runs the program
|
||||
/// only once the terminal answers; programs that lay out a prompt ask it too.
|
||||
const CURSOR_QUERY: &[u8] = b"\x1b[6n";
|
||||
|
||||
/// `chunk` without its cursor position queries, and how many there were.
|
||||
pub(crate) fn take_cursor_queries(chunk: &[u8]) -> (Vec<u8>, usize) {
|
||||
let mut out = Vec::with_capacity(chunk.len());
|
||||
let mut queries = 0;
|
||||
let mut rest = chunk;
|
||||
while let Some(at) = rest.windows(CURSOR_QUERY.len()).position(|w| w == CURSOR_QUERY) {
|
||||
out.extend_from_slice(&rest[..at]);
|
||||
rest = &rest[at + CURSOR_QUERY.len()..];
|
||||
queries += 1;
|
||||
}
|
||||
out.extend_from_slice(rest);
|
||||
(out, queries)
|
||||
}
|
||||
|
||||
/// Length of the end of `pending` that may begin a cursor position query the next read completes.
|
||||
pub(crate) fn partial_cursor_query(pending: &[u8]) -> usize {
|
||||
(1..CURSOR_QUERY.len()).rev().find(|&n| pending.ends_with(&CURSOR_QUERY[..n])).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept). The debug
|
||||
/// console is no terminal, so cursor position queries are answered here (top-left corner).
|
||||
/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
|
||||
fn forward_terminal_output(
|
||||
s: &Session,
|
||||
mut reader: Box<dyn std::io::Read + Send>,
|
||||
answer: Arc<ide_core::input::InputWriter>,
|
||||
#[cfg(unix)] mut wait_readable: impl FnMut() -> std::io::Result<()> + Send + 'static,
|
||||
) {
|
||||
let session = s.id;
|
||||
@@ -1119,20 +1078,11 @@ fn forward_terminal_output(
|
||||
break;
|
||||
}
|
||||
}
|
||||
let (rest, queries) = take_cursor_queries(&pending);
|
||||
pending = rest;
|
||||
for _ in 0..queries {
|
||||
if let Err(e) = answer.write(b"\x1b[1;1R") {
|
||||
tracing::warn!(%session, "debug terminal cursor position: {e}");
|
||||
}
|
||||
}
|
||||
// Keep incomplete UTF-8 sequences, a `\r` that may start a `\r\n`, and the start of
|
||||
// a cursor position query for the next chunk.
|
||||
let keep = partial_cursor_query(&pending);
|
||||
let mut valid = match std::str::from_utf8(&pending[..pending.len() - keep]) {
|
||||
Ok(_) => pending.len() - keep,
|
||||
// Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
|
||||
let mut valid = match std::str::from_utf8(&pending) {
|
||||
Ok(_) => pending.len(),
|
||||
Err(e) if e.error_len().is_none() => e.valid_up_to(),
|
||||
Err(_) => pending.len() - keep,
|
||||
Err(_) => pending.len(),
|
||||
};
|
||||
if valid > 0 && pending[valid - 1] == b'\r' {
|
||||
valid -= 1;
|
||||
|
||||
@@ -559,10 +559,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
}
|
||||
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
|
||||
"hotReload" => {
|
||||
ok!(msg, Value::Null);
|
||||
send!(json!({"type": "event", "event": "flutter.appStarted", "body": {}}));
|
||||
}
|
||||
"redefineClasses" => {
|
||||
send!(
|
||||
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": "STARTING", "message": "Start hot code replacement procedure..."}})
|
||||
@@ -1014,44 +1010,6 @@ async fn run_in_terminal_spawns_debuggee() {
|
||||
assert!(response["body"]["processId"].as_u64().unwrap() > 0);
|
||||
}
|
||||
|
||||
/// The debug console answers a terminal's cursor position query: ConPTY asks one before it runs
|
||||
/// the program at all (Windows debuggees never started), and programs that lay out a prompt ask too.
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_answers_cursor_position_queries() {
|
||||
#[cfg(unix)]
|
||||
let program = vec![
|
||||
"sh".into(),
|
||||
"-c".into(),
|
||||
r"stty -echo -icanon min 6; printf '\033[6n'; reply=$(dd bs=6 count=1 2>/dev/null); stty sane; case $reply in *'[1;1R') echo answered;; esac".into(),
|
||||
];
|
||||
#[cfg(windows)]
|
||||
let program = vec!["cmd".into(), "/c".into(), "echo answered".into()];
|
||||
let h = harness(Script { run_in_terminal: Some(program), ..Script::default() });
|
||||
h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("answered"))).await;
|
||||
let output: String = h
|
||||
.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } => Some(output.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert!(!output.contains("\x1b[6n"), "{output:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cursor_position_queries_are_taken_out_of_the_output() {
|
||||
use crate::session::{partial_cursor_query, take_cursor_queries};
|
||||
assert_eq!(take_cursor_queries(b"a\x1b[6nb\x1b[6n"), (b"ab".to_vec(), 2));
|
||||
assert_eq!(take_cursor_queries(b"\x1b[0mtext"), (b"\x1b[0mtext".to_vec(), 0));
|
||||
assert_eq!(partial_cursor_query(b"text\x1b["), 2);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[6"), 3);
|
||||
assert_eq!(partial_cursor_query(b"text\x1b[0m"), 0);
|
||||
assert_eq!(partial_cursor_query(b"text"), 0);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn run_in_terminal_program_reads_typed_input() {
|
||||
@@ -1895,17 +1853,6 @@ async fn startup_sends_every_file_at_once_and_skips_files_with_nothing_enabled()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn hot_reload_sends_its_reason_and_reports_the_flutter_app() {
|
||||
let h = harness(Script::default());
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.manager.hot_reload(id, HotReloadReason::Manual).await.unwrap();
|
||||
h.manager.hot_reload(id, HotReloadReason::Save).await.unwrap();
|
||||
let reasons: Vec<_> = requests(&h, "hotReload").iter().map(|args| args["reason"].clone()).collect();
|
||||
assert_eq!(reasons, [json!("manual"), json!("save")]);
|
||||
h.wait_event(|e| matches!(e, DebugEvent::FlutterAppStarted)).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn hot_swap_only_for_java_debug() {
|
||||
let h = harness(Script::default());
|
||||
@@ -2295,16 +2242,6 @@ fn flutter_projects_are_found_from_the_program_or_the_working_directory() {
|
||||
std::fs::remove_dir_all(&root).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_flutter_device_follows_the_tool_arguments() {
|
||||
let mut arguments = json!({ "toolArgs": ["--flavor", "dev"] });
|
||||
add_flutter_device(&mut arguments, json!("macos"));
|
||||
assert_eq!(arguments["toolArgs"], json!(["--flavor", "dev", "-d", "macos"]));
|
||||
let mut arguments = json!({});
|
||||
add_flutter_device(&mut arguments, json!("chrome"));
|
||||
assert_eq!(arguments["toolArgs"], json!(["-d", "chrome"]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rdbg_runs_the_debuggee_after_its_options_with_the_configuration_environment() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -7,9 +7,6 @@ license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
ide-core.workspace = true
|
||||
ide-sdk.workspace = true
|
||||
tempfile.workspace = true
|
||||
zip.workspace = true
|
||||
dunce.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json = { workspace = true, features = ["raw_value"] }
|
||||
@@ -41,4 +38,5 @@ open = "5"
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true, features = ["rt-multi-thread", "macros", "net"] }
|
||||
tempfile.workspace = true
|
||||
ide-ssh = { workspace = true, features = ["testing"] }
|
||||
@@ -18,21 +18,14 @@ struct State {
|
||||
database: String,
|
||||
settings: Vec<(String, String)>,
|
||||
read_only: bool,
|
||||
session: Mutex<Session>,
|
||||
session_id: String,
|
||||
session: Mutex<bool>,
|
||||
closed: CancellationToken,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Session {
|
||||
id: Option<String>,
|
||||
initialized: bool,
|
||||
strict_read_only: bool,
|
||||
}
|
||||
|
||||
/// The response format: a names line, a types line, then one JSON array per row, so rows past
|
||||
/// the grid's limit are skipped without being parsed.
|
||||
const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
|
||||
const SESSION_LOST: &str = "ClickHouse HTTP session expired or is missing on this node (code 372). Reconnect to start a new session. Behind a load balancer, use one node or session affinity, or set use_http_session=false in Advanced for independent queries.";
|
||||
|
||||
pub(crate) fn transaction_error() -> IdeError {
|
||||
IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
|
||||
@@ -43,32 +36,11 @@ impl ClickhousePool {
|
||||
if source.options.transaction == DbTxMode::Manual {
|
||||
return Err(transaction_error());
|
||||
}
|
||||
let mut use_http_session = None;
|
||||
let mut settings = Vec::with_capacity(setup.params.len());
|
||||
for (name, value) in setup.params {
|
||||
if name.eq_ignore_ascii_case("use_http_session") {
|
||||
if use_http_session.is_some() {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be specified only once"));
|
||||
}
|
||||
use_http_session = Some(if value.eq_ignore_ascii_case("true") {
|
||||
true
|
||||
} else if value.eq_ignore_ascii_case("false") {
|
||||
false
|
||||
} else {
|
||||
return Err(IdeError::invalid("ClickHouse use_http_session must be true or false"));
|
||||
});
|
||||
} else if reserved_setting(&name) {
|
||||
for (name, _) in &setup.params {
|
||||
if reserved_setting(name) {
|
||||
return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
|
||||
} else {
|
||||
settings.push((name, value));
|
||||
}
|
||||
}
|
||||
let use_http_session = use_http_session.unwrap_or(true);
|
||||
if !use_http_session && (!setup.statements.is_empty() || !source.options.startup_script.trim().is_empty()) {
|
||||
return Err(IdeError::invalid(
|
||||
"ClickHouse use_http_session=false does not support startup scripts; configure database and settings on the data source for each request",
|
||||
));
|
||||
}
|
||||
let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
|
||||
let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
|
||||
if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
|
||||
@@ -133,50 +105,16 @@ impl ClickhousePool {
|
||||
endpoint,
|
||||
user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
|
||||
password: password.unwrap_or_default().to_owned(),
|
||||
database: database.into(),
|
||||
settings,
|
||||
database: if database.is_empty() { "default".into() } else { database.into() },
|
||||
settings: setup.params,
|
||||
read_only: source.read_only,
|
||||
session: Mutex::new(Session {
|
||||
id: use_http_session.then(|| uuid::Uuid::new_v4().to_string()),
|
||||
..Session::default()
|
||||
}),
|
||||
session_id: uuid::Uuid::new_v4().to_string(),
|
||||
session: Mutex::new(false),
|
||||
closed: CancellationToken::new(),
|
||||
}));
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
return Err(error);
|
||||
}
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
// USE once so later queries inherit the selection (and may change it).
|
||||
if use_http_session && !database.is_empty() {
|
||||
let name = crate::sql::quote_ident(crate::DbDriver::Clickhouse, database);
|
||||
pool.execute(&format!("USE {name}"), 0, &cancel).await?;
|
||||
}
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
for sql in setup.statements {
|
||||
pool.execute(&sql, 0, &cancel).await?;
|
||||
}
|
||||
@@ -213,30 +151,27 @@ impl ClickhousePool {
|
||||
}
|
||||
|
||||
/// `max_rows`: the rows the server may send (the skipped ones included).
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, session: &Session) -> RequestBuilder {
|
||||
fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
|
||||
.query(&self.0.settings)
|
||||
.query(&[("query_id", query_id), ("default_format", FORMAT)]);
|
||||
if !session.strict_read_only {
|
||||
request = request.query(&[
|
||||
.query(&[
|
||||
("session_id", self.0.session_id.clone()),
|
||||
("session_timeout", "3600".into()),
|
||||
("query_id", query_id.to_owned()),
|
||||
("default_format", FORMAT.into()),
|
||||
("output_format_json_quote_denormals", "1".into()),
|
||||
("max_result_rows", max_rows.saturating_add(1).to_string()),
|
||||
("result_overflow_mode", "break".into()),
|
||||
]);
|
||||
}
|
||||
if let Some(session_id) = &session.id {
|
||||
request = request.query(&[("session_id", session_id.as_str()), ("session_timeout", "3600")]);
|
||||
if session.initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
}
|
||||
}
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
if initialized {
|
||||
request = request.query(&[("session_check", "1")]);
|
||||
} else {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -265,7 +200,7 @@ impl ClickhousePool {
|
||||
};
|
||||
let client = self.client()?;
|
||||
let query_id = uuid::Uuid::new_v4().to_string();
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), &session).body(sql.to_owned());
|
||||
let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
|
||||
let started = Instant::now();
|
||||
let fetch = async {
|
||||
let mut response = request.send().await.map_err(http_error)?;
|
||||
@@ -319,7 +254,7 @@ impl ClickhousePool {
|
||||
match result {
|
||||
Some(result) => {
|
||||
if result.is_ok() {
|
||||
session.initialized = true;
|
||||
*session = true;
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -372,7 +307,11 @@ impl ClickhousePool {
|
||||
let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
|
||||
|| matches!(code, Some("193" | "194" | "195" | "516" | "497"));
|
||||
let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
|
||||
let detail = if code == Some("372") || session_not_found(detail) { SESSION_LOST } else { detail };
|
||||
let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
|
||||
"ClickHouse HTTP session expired; reconnect to restore session settings"
|
||||
} else {
|
||||
detail
|
||||
};
|
||||
self.redact_error(IdeError::new(
|
||||
if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
|
||||
format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
|
||||
@@ -384,9 +323,9 @@ type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
|
||||
|
||||
/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
|
||||
/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
|
||||
/// unparsed, so a grid limit bounds memory even if a strict read-only server does not allow
|
||||
/// per-query result limits. A line that is not a JSON array starts the exception ClickHouse
|
||||
/// writes when a query fails mid-stream.
|
||||
/// unparsed, so a grid limit bounds memory however large the block
|
||||
/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
|
||||
/// starts the exception ClickHouse writes when a query fails mid-stream.
|
||||
struct RowReader {
|
||||
skip: usize,
|
||||
max_rows: usize,
|
||||
@@ -494,11 +433,7 @@ impl RowReader {
|
||||
let rest = std::mem::take(&mut self.pending);
|
||||
self.line(&rest)?;
|
||||
if let Some(exception) = self.exception {
|
||||
let detail = exception_text(&exception);
|
||||
return Err(IdeError::invalid(format!(
|
||||
"ClickHouse: {}",
|
||||
if session_not_found(detail) { SESSION_LOST } else { detail }
|
||||
)));
|
||||
return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
|
||||
}
|
||||
let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
|
||||
let types = self.types.unwrap_or_default();
|
||||
@@ -510,13 +445,6 @@ impl RowReader {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a server message reports a named HTTP session this node doesn't have.
|
||||
fn session_not_found(detail: &str) -> bool {
|
||||
detail.starts_with("Code: 372.")
|
||||
|| detail.starts_with("Session not found")
|
||||
|| detail.starts_with("SESSION_NOT_FOUND")
|
||||
}
|
||||
|
||||
/// The server's message in a failed response: rows already streamed and the
|
||||
/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
|
||||
fn exception_text(body: &str) -> &str {
|
||||
@@ -551,20 +479,6 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn reserved_setting(name: &str) -> bool {
|
||||
let name = name.to_ascii_lowercase();
|
||||
name.starts_with("output_format_json_")
|
||||
@@ -661,19 +575,6 @@ mod tests {
|
||||
DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
|
||||
}
|
||||
|
||||
fn property(name: &str, value: &str) -> DbProperty {
|
||||
DbProperty { name: name.into(), value: value.into() }
|
||||
}
|
||||
|
||||
fn request_url(request: &str) -> Url {
|
||||
let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
Url::parse(&format!("http://localhost{target}")).unwrap()
|
||||
}
|
||||
|
||||
fn query_value(url: &Url, key: &str) -> Option<String> {
|
||||
url.query_pairs().find(|(name, _)| name == key).map(|(_, value)| value.into_owned())
|
||||
}
|
||||
|
||||
fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
|
||||
decode_from(body, 0, max_rows, chunk)
|
||||
}
|
||||
@@ -752,7 +653,6 @@ mod tests {
|
||||
let (port, requests) = server(vec![
|
||||
("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", ""),
|
||||
(
|
||||
"200 OK",
|
||||
"X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
|
||||
@@ -764,7 +664,7 @@ mod tests {
|
||||
user: "reader".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("max_threads", "2"), property("use_http_session", "true")],
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
|
||||
@@ -787,7 +687,7 @@ mod tests {
|
||||
assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
|
||||
assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
|
||||
assert_eq!(value(&urls[3], "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
|
||||
for (request, url) in requests.iter().zip(&urls) {
|
||||
assert!(request.starts_with("POST /?"));
|
||||
assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
|
||||
@@ -795,10 +695,8 @@ mod tests {
|
||||
assert_eq!(value(url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(value(url, "use_http_session"), None);
|
||||
}
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("USE `analytics`"));
|
||||
assert!(pool.transaction(&[]).await.is_err());
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
@@ -808,85 +706,6 @@ mod tests {
|
||||
assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_unset_database_uses_the_accounts_default_in_both_modes() {
|
||||
for mode in ["true", "false"] {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE); 2]).await;
|
||||
let source = DataSource { properties: vec![property("use_http_session", mode)], ..source(port) };
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
|
||||
for request in requests.await.unwrap() {
|
||||
assert_eq!(query_value(&request_url(&request), "database"), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_requests_keep_database_settings_readonly_and_limits() {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE); 3]).await;
|
||||
let source = DataSource {
|
||||
database: "configured_database".into(),
|
||||
read_only: true,
|
||||
options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
pool.execute("SELECT 2", 2, &CancellationToken::new()).await.unwrap();
|
||||
pool.execute("SELECT 3", 3, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
let mut query_ids = std::collections::HashSet::new();
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name} must not be sent in stateless mode");
|
||||
}
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("analytics"));
|
||||
assert_eq!(query_value(&url, "session_timezone").as_deref(), Some("UTC"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "max_result_rows"), Some((index + 2).to_string()));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), Some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "default_format").as_deref(), Some(FORMAT));
|
||||
assert!(query_ids.insert(query_value(&url, "query_id").unwrap()));
|
||||
assert!(request.ends_with(&format!("SELECT {}", index + 1)));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn default_session_expiry_never_recreates_the_session_or_replays_sql() {
|
||||
for failure in [
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 372\r\n", "session unavailable"),
|
||||
("500 Internal Server Error", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
("200 OK", "", "Code: 372. DB::Exception: Session not found. (SESSION_NOT_FOUND)"),
|
||||
] {
|
||||
let (port, requests) = server(vec![("200 OK", "", ONE), failure, ("200 OK", "", ONE)]).await;
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let sql = "INSERT INTO events VALUES (1)";
|
||||
let error = pool.execute(sql, 0, &CancellationToken::new()).await.unwrap_err();
|
||||
assert!(error.message.contains("372"));
|
||||
assert!(error.message.contains("one node or session affinity"));
|
||||
assert!(error.message.contains("Reconnect"));
|
||||
assert!(error.message.contains("use_http_session=false"));
|
||||
pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap();
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 3);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with(sql));
|
||||
assert!(requests[2].ends_with("SELECT 1"));
|
||||
let session_id = query_value(&request_url(&requests[0]), "session_id").unwrap();
|
||||
for request in &requests[1..] {
|
||||
let url = request_url(request);
|
||||
assert_eq!(query_value(&url, "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert_eq!(query_value(&url, "session_check").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database"), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sequential_queries_reuse_the_http_connection() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
@@ -907,144 +726,6 @@ mod tests {
|
||||
task.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connects_when_server_forbids_settings_in_readonly_mode() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'output_format_json_quote_denormals' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", ONE),
|
||||
("200 OK", "", ""),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "system".into(),
|
||||
read_only: true,
|
||||
properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let result = pool.execute("SELECT number FROM numbers(2)", 1, &CancellationToken::new()).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into())]]);
|
||||
assert!(result.has_more);
|
||||
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[0].contains("output_format_json_quote_denormals=1"));
|
||||
assert!(requests[1].ends_with("SELECT getSetting('readonly')"));
|
||||
assert!(!requests[1].contains("session_check="));
|
||||
assert_eq!(query_value(&request_url(&requests[1]), "database").as_deref(), Some("system"));
|
||||
assert!(requests[2].contains("session_check=1"));
|
||||
let session_id = query_value(&request_url(&requests[1]), "session_id").unwrap();
|
||||
assert_ne!(query_value(&request_url(&requests[0]), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
for request in &requests[1..] {
|
||||
assert_eq!(query_value(&request_url(request), "session_id").as_deref(), Some(session_id.as_str()));
|
||||
assert!(request.contains("default_format=JSONCompactEachRowWithNamesAndTypes"));
|
||||
assert!(request.contains("max_threads=2"));
|
||||
for setting in
|
||||
["output_format_json_quote_denormals=", "max_result_rows=", "result_overflow_mode=", "readonly="]
|
||||
{
|
||||
assert!(!request.contains(setting), "{setting} is not allowed in a strict read-only session");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
let url = request_url(&requests[0]);
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), read_only.then_some("1"));
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incompatible_stateless_options_are_rejected_before_connecting() {
|
||||
for (properties, startup_script, expected) in [
|
||||
(vec![property("use_http_session", "false")], "SET max_threads = 2", "does not support startup scripts"),
|
||||
(vec![property("use_http_session", "invalid")], "", "must be true or false"),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("USE_HTTP_SESSION", "true")],
|
||||
"",
|
||||
"must be specified only once",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_id", "custom")],
|
||||
"",
|
||||
"manages the session_id",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_check", "0")],
|
||||
"",
|
||||
"manages the session_check",
|
||||
),
|
||||
(
|
||||
vec![property("use_http_session", "false"), property("session_timeout", "60")],
|
||||
"",
|
||||
"manages the session_timeout",
|
||||
),
|
||||
] {
|
||||
let source = DataSource {
|
||||
properties,
|
||||
options: DbOptions { startup_script: startup_script.into(), ..Default::default() },
|
||||
..source(1)
|
||||
};
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("incompatible options must fail");
|
||||
assert!(error.message.contains(expected), "{}", error.message);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn readonly_probe_does_not_disable_settings_on_a_writable_session() {
|
||||
let (port, requests) = server(vec![
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"readonly\"]\n[\"UInt64\"]\n[0]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource { read_only: true, ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("writable session must stay rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(requests.await.unwrap()[1].ends_with("SELECT getSetting('readonly')"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn readonly_probe_matches_only_the_driver_settings() {
|
||||
for (code, setting, expected) in [
|
||||
(164, "max_result_rows", true),
|
||||
(164, "result_overflow_mode", true),
|
||||
(164, "readonly", true),
|
||||
(164, "max_threads", false),
|
||||
(516, "max_result_rows", false),
|
||||
] {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn server_errors_keep_details_and_hide_passwords() {
|
||||
let (port, requests) = server(vec![(
|
||||
|
||||
@@ -237,7 +237,6 @@ pub enum Pool {
|
||||
Mysql(ServerPool<MysqlManager>),
|
||||
SqlServer(Bb8Pool<MssqlConnectionManager>),
|
||||
Clickhouse(crate::clickhouse::ClickhousePool),
|
||||
Jdbc(Box<crate::jdbc::JdbcPool>),
|
||||
Oracle(crate::oracle::OraclePool),
|
||||
Snowflake(crate::snowflake::SnowflakePool),
|
||||
}
|
||||
@@ -730,7 +729,6 @@ impl Pool {
|
||||
Pool::Mysql(_) => DbDriver::Mysql,
|
||||
Pool::SqlServer(_) => DbDriver::SqlServer,
|
||||
Pool::Clickhouse(_) => DbDriver::Clickhouse,
|
||||
Pool::Jdbc(_) => DbDriver::Jdbc,
|
||||
Pool::Oracle(_) => DbDriver::Oracle,
|
||||
Pool::Snowflake(_) => DbDriver::Snowflake,
|
||||
}
|
||||
@@ -921,7 +919,6 @@ impl Pool {
|
||||
conn.query("SELECT 1", &[]).await.map_err(mssql_err)?.into_results().await.map_err(mssql_err)?;
|
||||
Ok(Pool::SqlServer(pool))
|
||||
}
|
||||
DbDriver::Jdbc => Err(IdeError::invalid("An installed JDBC driver profile is required")),
|
||||
DbDriver::Clickhouse => unreachable!(),
|
||||
DbDriver::Oracle | DbDriver::Snowflake => unreachable!(),
|
||||
}
|
||||
@@ -931,7 +928,6 @@ impl Pool {
|
||||
match self {
|
||||
Pool::SqlServer(_) | Pool::Oracle(_) => {}
|
||||
Pool::Clickhouse(p) => p.close(),
|
||||
Pool::Jdbc(p) => p.close().await,
|
||||
Pool::Snowflake(p) => p.close().await,
|
||||
Pool::Sqlite(p) => p.close().await,
|
||||
Pool::Postgres(p) => p.closed.store(true, Ordering::Relaxed),
|
||||
@@ -944,7 +940,6 @@ impl Pool {
|
||||
Pool::SqlServer(_) => false,
|
||||
Pool::Oracle(p) => p.is_closed(),
|
||||
Pool::Clickhouse(p) => p.is_closed(),
|
||||
Pool::Jdbc(p) => p.is_closed(),
|
||||
Pool::Snowflake(p) => p.is_closed(),
|
||||
Pool::Sqlite(p) => p.is_closed(),
|
||||
Pool::Postgres(p) => p.closed.load(Ordering::Relaxed),
|
||||
@@ -954,9 +949,6 @@ impl Pool {
|
||||
|
||||
/// Runs `sql` (no row limit beyond `max`), for introspection: cells are text (see [`Cells::Text`]).
|
||||
pub async fn rows(&self, sql: &str, max: usize) -> IdeResult<Vec<Vec<Option<String>>>> {
|
||||
if let Pool::Jdbc(p) = self {
|
||||
return Ok(p.query(sql, 0, max, &CancellationToken::new()).await?.rows);
|
||||
}
|
||||
if let Pool::Clickhouse(p) = self {
|
||||
return Ok(p.execute(sql, max, &CancellationToken::new()).await?.rows);
|
||||
}
|
||||
@@ -984,9 +976,6 @@ impl Pool {
|
||||
max_rows: usize,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<QueryResult> {
|
||||
if let Pool::Jdbc(p) = self {
|
||||
return p.query(sql, skip, max_rows, cancel).await;
|
||||
}
|
||||
if let Pool::Clickhouse(p) = self {
|
||||
return p.execute_from(sql, skip, max_rows, cancel).await;
|
||||
}
|
||||
@@ -1009,7 +998,6 @@ impl Pool {
|
||||
/// row when flagged (table editor submits).
|
||||
pub async fn transaction(&self, statements: &[(String, bool)]) -> IdeResult<u64> {
|
||||
match self {
|
||||
Pool::Jdbc(_) => Err(IdeError::invalid("Custom JDBC table editing is unsupported")),
|
||||
Pool::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
|
||||
Pool::Snowflake(p) => p.transaction(statements).await,
|
||||
Pool::SqlServer(_) => {
|
||||
@@ -1100,7 +1088,6 @@ pub enum Held {
|
||||
impl Held {
|
||||
pub async fn acquire(pool: &Pool) -> IdeResult<Self> {
|
||||
Ok(match pool {
|
||||
Pool::Jdbc(_) => return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported")),
|
||||
Pool::Sqlite(p) => Held::Sqlite(p.acquire().await.map_err(db_err)?),
|
||||
Pool::Postgres(p) => Held::Postgres(Box::new(p.get().await?)),
|
||||
Pool::Mysql(p) => Held::Mysql(Box::new(p.get().await?)),
|
||||
@@ -1390,7 +1377,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {
|
||||
DbDriver::Mysql => "START TRANSACTION",
|
||||
DbDriver::SqlServer => "BEGIN TRAN",
|
||||
DbDriver::Oracle => "", // opens implicitly with autocommit off
|
||||
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake | DbDriver::Jdbc => "BEGIN",
|
||||
DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse | DbDriver::Snowflake => "BEGIN",
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,678 +0,0 @@
|
||||
//! A trusted local driver profile is shared by data sources. JDBC URLs and properties
|
||||
//! can run driver-specific initialization. A project source may connect only with the
|
||||
//! settings its user last accepted in the dialog; the approval lives outside the project.
|
||||
use crate::{DataSource, DbManager, QueryResult, ResultColumn};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::io::{Cursor, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
|
||||
use tokio::process::{ChildStdin, ChildStdout, Command};
|
||||
use tokio::sync::Mutex;
|
||||
use tokio::time::{Instant as Deadline, timeout_at};
|
||||
|
||||
const LIMIT: usize = 16 * 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbJdbcDriver {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub jars: Vec<String>,
|
||||
pub class_name: String,
|
||||
pub url_template: String,
|
||||
}
|
||||
|
||||
fn persist_local(path: &Path, data: &[u8]) -> IdeResult<()> {
|
||||
let dir = path.parent().expect("registry paths have a parent");
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let mut tmp = tempfile::NamedTempFile::new_in(dir)?;
|
||||
std::io::Write::write_all(&mut tmp, data)?;
|
||||
tmp.persist(path).map_err(|e| IdeError::from(e.error))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn local_jar(jar: &str) -> IdeResult<&Path> {
|
||||
if jar.contains(if cfg!(windows) { ';' } else { ':' }) {
|
||||
return Err(IdeError::invalid("A JDBC JAR path contains the system classpath separator"));
|
||||
}
|
||||
let path = Path::new(jar);
|
||||
if !path.is_absolute() || !path.is_file() || !path.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("jar")) {
|
||||
return Err(IdeError::invalid("Choose an existing local .jar file for each JDBC driver file"));
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
/// Read the standard JDBC service descriptors without executing any driver code.
|
||||
pub fn jdbc_driver_classes(jars: &[String]) -> IdeResult<Vec<String>> {
|
||||
let mut classes = Vec::new();
|
||||
if jars.len() > 128 {
|
||||
return Err(IdeError::invalid("Choose at most 128 JDBC driver files"));
|
||||
}
|
||||
for jar in jars {
|
||||
let file = std::fs::File::open(local_jar(jar)?)?;
|
||||
let mut archive = zip::ZipArchive::new(file).map_err(|_| IdeError::invalid("Invalid JDBC JAR archive"))?;
|
||||
let descriptor = match archive.by_name("META-INF/services/java.sql.Driver") {
|
||||
Ok(entry) => entry,
|
||||
Err(zip::result::ZipError::FileNotFound) => continue,
|
||||
Err(_) => return Err(IdeError::invalid("Cannot read the JDBC driver descriptor")),
|
||||
};
|
||||
let mut text = String::new();
|
||||
descriptor.take(65537).read_to_string(&mut text)?;
|
||||
if text.len() > 65536 {
|
||||
return Err(IdeError::invalid("JDBC driver descriptor is too large"));
|
||||
}
|
||||
for line in text.lines() {
|
||||
let name = line.split('#').next().unwrap_or_default().trim();
|
||||
if !name.is_empty()
|
||||
&& name.split('.').all(|part| {
|
||||
let mut chars = part.chars();
|
||||
chars.next().is_some_and(|c| c.is_alphabetic() || matches!(c, '_' | '$'))
|
||||
&& chars.all(|c| c.is_alphanumeric() || matches!(c, '_' | '$'))
|
||||
})
|
||||
&& !classes.iter().any(|s| s == name)
|
||||
{
|
||||
classes.push(name.to_owned());
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(classes)
|
||||
}
|
||||
|
||||
impl DbJdbcDriver {
|
||||
fn validate(&self) -> IdeResult<()> {
|
||||
if self.id.is_empty()
|
||||
|| self.name.trim().is_empty()
|
||||
|| self.jars.is_empty()
|
||||
|| self.class_name.trim().is_empty()
|
||||
{
|
||||
return Err(IdeError::invalid("A JDBC driver needs a name, a driver class and at least one JAR"));
|
||||
}
|
||||
if !self.url_template.is_empty() && !self.url_template.starts_with("jdbc:") {
|
||||
return Err(IdeError::invalid("The JDBC URL template must start with jdbc:"));
|
||||
}
|
||||
for jar in &self.jars {
|
||||
local_jar(jar)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl DbManager {
|
||||
fn jdbc_registry(&self) -> IdeResult<PathBuf> {
|
||||
self.global
|
||||
.as_ref()
|
||||
.map(|(dir, _)| dir.join("jdbc-drivers.json"))
|
||||
.ok_or_else(|| IdeError::invalid("Global JDBC driver profiles are unavailable here"))
|
||||
}
|
||||
|
||||
pub fn jdbc_drivers(&self) -> IdeResult<Vec<DbJdbcDriver>> {
|
||||
let path = self.jdbc_registry()?;
|
||||
match std::fs::File::open(path) {
|
||||
Ok(file) => {
|
||||
serde_json::from_reader(file).map_err(|e| IdeError::invalid(format!("JDBC driver profiles: {e}")))
|
||||
}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(vec![]),
|
||||
Err(e) => Err(e.into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn update_jdbc_driver(&self, id: &str, driver: Option<DbJdbcDriver>) -> IdeResult<()> {
|
||||
let _guard = crate::plugin::EDIT.lock();
|
||||
let path = self.jdbc_registry()?;
|
||||
let mut list = self.jdbc_drivers()?;
|
||||
list.retain(|d| d.id != id);
|
||||
list.extend(driver);
|
||||
let data = serde_json::to_vec_pretty(&list).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
persist_local(&path, &data)
|
||||
}
|
||||
|
||||
pub fn save_jdbc_driver(&self, driver: DbJdbcDriver) -> IdeResult<()> {
|
||||
driver.validate()?;
|
||||
self.update_jdbc_driver(&driver.id.clone(), Some(driver))
|
||||
}
|
||||
|
||||
pub fn remove_jdbc_driver(&self, id: &str) -> IdeResult<()> {
|
||||
if self.global_sources().iter().any(|s| s.driver == crate::DbDriver::Jdbc && s.jdbc_driver == id) {
|
||||
return Err(IdeError::invalid("This JDBC driver is in use by a data source"));
|
||||
}
|
||||
self.update_jdbc_driver(id, None)
|
||||
}
|
||||
|
||||
fn jdbc_approval(&self, source: &DataSource) -> IdeResult<(PathBuf, String)> {
|
||||
let registry = self.jdbc_registry()?;
|
||||
let key = serde_json::to_vec(&(&self.root, &source.id)).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
let settings = serde_json::to_vec(&(
|
||||
&source.jdbc_driver,
|
||||
&source.url,
|
||||
&source.user,
|
||||
source.read_only,
|
||||
&source.properties,
|
||||
&source.options,
|
||||
))
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
Ok((
|
||||
registry.with_file_name("jdbc-approvals").join(blake3::hash(&key).to_hex().as_str()),
|
||||
blake3::hash(&settings).to_hex().to_string(),
|
||||
))
|
||||
}
|
||||
|
||||
/// Called only for the source the user explicitly saved in the connection dialog.
|
||||
pub fn approve_jdbc_source(&self, source: &DataSource) -> IdeResult<()> {
|
||||
if source.driver != crate::DbDriver::Jdbc || source.plugin_owner.is_some() {
|
||||
return Err(IdeError::invalid("Expected a user-managed JDBC data source"));
|
||||
}
|
||||
let (path, fingerprint) = self.jdbc_approval(source)?;
|
||||
persist_local(&path, fingerprint.as_bytes())
|
||||
}
|
||||
|
||||
pub(crate) async fn open_pool(
|
||||
&self,
|
||||
source: &DataSource,
|
||||
password: Option<&str>,
|
||||
testing: bool,
|
||||
) -> IdeResult<crate::Pool> {
|
||||
if source.driver != crate::DbDriver::Jdbc {
|
||||
return crate::Pool::connect(source, password, Some(&self.root)).await;
|
||||
}
|
||||
if source.plugin_owner.is_some() {
|
||||
return Err(IdeError::invalid("Plugins cannot start custom JDBC drivers"));
|
||||
}
|
||||
if !testing && !source.global {
|
||||
let (path, expected) = self.jdbc_approval(source)?;
|
||||
if std::fs::read_to_string(path).ok().as_deref() != Some(&expected) {
|
||||
return Err(IdeError::invalid(
|
||||
"Review this project's JDBC URL and properties, then save the data source before connecting",
|
||||
));
|
||||
}
|
||||
}
|
||||
let driver = self
|
||||
.jdbc_drivers()?
|
||||
.into_iter()
|
||||
.find(|d| d.id == source.jdbc_driver)
|
||||
.ok_or_else(|| IdeError::invalid("Select an installed JDBC driver profile"))?;
|
||||
JdbcPool::connect(source, password, driver, self.jdbc_registry()?.with_file_name("jdbc"))
|
||||
.await
|
||||
.map(Box::new)
|
||||
.map(crate::Pool::Jdbc)
|
||||
}
|
||||
}
|
||||
|
||||
struct Bridge {
|
||||
stop: tokio::sync::oneshot::Sender<()>,
|
||||
exited: tokio::task::JoinHandle<()>,
|
||||
sequence: u64,
|
||||
input: ChildStdin,
|
||||
output: ChildStdout,
|
||||
}
|
||||
|
||||
pub struct JdbcPool {
|
||||
bridge: Mutex<Option<Bridge>>,
|
||||
closed: CancellationToken,
|
||||
pub(crate) version: String,
|
||||
pub(crate) identifier_quote: String,
|
||||
}
|
||||
|
||||
impl Bridge {
|
||||
fn start(cache: &Path, jars: &[String]) -> IdeResult<Self> {
|
||||
let jdks = ide_sdk::java::installed_jdks();
|
||||
let java = ide_sdk::java::java_runtime(&jdks, 17)
|
||||
.ok_or_else(|| IdeError::invalid("Install a Java 17 or newer runtime to use custom JDBC drivers"))?;
|
||||
let jar = ide_sdk::java::jdbc_bridge_jar(cache)
|
||||
.ok_or_else(|| IdeError::invalid("Cannot install the JDBC bridge in the application data directory"))?;
|
||||
let classpath = std::env::join_paths(std::iter::once(jar.as_path()).chain(jars.iter().map(Path::new)))
|
||||
.map_err(|_| IdeError::invalid("A JDBC JAR path contains the system classpath separator"))?;
|
||||
// Embedded databases can resolve file URLs against the JVM's working directory.
|
||||
let files = cache.join("files");
|
||||
std::fs::create_dir_all(&files)?;
|
||||
let mut command = Command::new(ide_sdk::java::java_executable(&java.home));
|
||||
command.current_dir(files);
|
||||
ide_core::process::prepare(command.as_std_mut());
|
||||
let mut child = command
|
||||
.args(["-Xms8m", "-Xmx192m", "--enable-native-access=ALL-UNNAMED", "-cp"])
|
||||
.arg(classpath)
|
||||
.arg("ai.openidea.jdbc.OpenIdeaJdbc")
|
||||
.env_remove("CLASSPATH")
|
||||
.env_remove("JDK_JAVA_OPTIONS")
|
||||
.env_remove("JAVA_TOOL_OPTIONS")
|
||||
.env_remove("_JAVA_OPTIONS")
|
||||
.kill_on_drop(true)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()?;
|
||||
let input = child.stdin.take().expect("piped");
|
||||
let output = child.stdout.take().expect("piped");
|
||||
let (stop, stopped) = tokio::sync::oneshot::channel();
|
||||
let exited = tokio::spawn(async move {
|
||||
tokio::select! {
|
||||
stop = stopped => {
|
||||
// Disconnect closes stdin so a file-backed driver can flush. A dropped
|
||||
// request or an unresponsive driver must be reaped without waiting.
|
||||
if stop.is_err() || tokio::time::timeout(Duration::from_secs(2), child.wait()).await.is_err() {
|
||||
let _ = child.kill().await;
|
||||
}
|
||||
}
|
||||
_ = child.wait() => {}
|
||||
}
|
||||
});
|
||||
Ok(Self { input, output, stop, exited, sequence: 0 })
|
||||
}
|
||||
|
||||
async fn close(self) {
|
||||
drop(self.input);
|
||||
let _ = self.stop.send(());
|
||||
let _ = self.exited.await;
|
||||
}
|
||||
}
|
||||
|
||||
// Request: u64 request id, u32 field count, then length-prefixed UTF-8 fields.
|
||||
// Zero fields cancels that id. Replies have a u32 length; zero acknowledges Cancel.
|
||||
fn encode(id: u64, fields: &[&str]) -> IdeResult<Vec<u8>> {
|
||||
if fields.is_empty() || fields.len() > 8192 {
|
||||
return Err(IdeError::invalid("Invalid JDBC field count"));
|
||||
}
|
||||
let size = fields
|
||||
.iter()
|
||||
.try_fold(12usize, |n, s| n.checked_add(4)?.checked_add(s.len()).filter(|n| *n <= LIMIT))
|
||||
.ok_or_else(|| IdeError::invalid("JDBC request exceeds 16 MiB"))?;
|
||||
let mut data = Vec::with_capacity(size);
|
||||
data.extend_from_slice(&id.to_be_bytes());
|
||||
data.extend_from_slice(&(fields.len() as u32).to_be_bytes());
|
||||
for field in fields {
|
||||
data.extend_from_slice(&(field.len() as u32).to_be_bytes());
|
||||
data.extend_from_slice(field.as_bytes());
|
||||
}
|
||||
Ok(data)
|
||||
}
|
||||
|
||||
async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>> {
|
||||
let n = output.read_u32().await? as usize;
|
||||
if n > LIMIT {
|
||||
return Err(IdeError::invalid("JDBC response exceeds 16 MiB"));
|
||||
}
|
||||
let mut data = vec![0; n];
|
||||
output.read_exact(&mut data).await?;
|
||||
Ok(data)
|
||||
}
|
||||
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
input: &mut (impl AsyncWrite + Unpin),
|
||||
output: &mut (impl AsyncRead + Unpin),
|
||||
frame: Vec<u8>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Option<Vec<u8>>> {
|
||||
let mut stop = [0; 12];
|
||||
stop[..8].copy_from_slice(&frame[..8]);
|
||||
let early_deadline = {
|
||||
let send = input.write_all(&frame);
|
||||
tokio::pin!(send);
|
||||
tokio::select! {
|
||||
result = &mut send => { result?; None },
|
||||
() = cancel.cancelled() => {
|
||||
let end = Deadline::now() + CANCEL_GRACE;
|
||||
timeout_at(end, send).await.map_err(|_| cancel_timeout())??;
|
||||
Some(end)
|
||||
}
|
||||
}
|
||||
};
|
||||
drop(frame);
|
||||
let (first, deadline) = {
|
||||
let reply = read_frame(output);
|
||||
tokio::pin!(reply);
|
||||
let end = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => early_deadline.unwrap_or_else(|| Deadline::now() + CANCEL_GRACE),
|
||||
data = &mut reply => {
|
||||
let data = data?;
|
||||
if data.is_empty() { return Err(IdeError::invalid("Unexpected JDBC cancellation acknowledgement")); }
|
||||
return Ok(Some(data));
|
||||
}
|
||||
};
|
||||
let first = timeout_at(end, async {
|
||||
input.write_all(&stop).await?;
|
||||
reply.await
|
||||
})
|
||||
.await
|
||||
.map_err(|_| cancel_timeout())??;
|
||||
(first, end)
|
||||
};
|
||||
// Drain both frames before the next statement can use this session. The driver
|
||||
// may complete the statement before or after the control thread acknowledges it.
|
||||
let data = if first.is_empty() {
|
||||
timeout_at(deadline, read_frame(output)).await.map_err(|_| cancel_timeout())??
|
||||
} else {
|
||||
if timeout_at(deadline, output.read_u32()).await.map_err(|_| cancel_timeout())?? != 0 {
|
||||
return Err(IdeError::invalid("Invalid JDBC cancellation acknowledgement"));
|
||||
}
|
||||
first
|
||||
};
|
||||
match data.first() {
|
||||
// A committed statement may have finished before the control thread received Cancel.
|
||||
Some(1) => Ok(Some(data)),
|
||||
Some(0) => Ok(None),
|
||||
_ => Err(IdeError::invalid("Invalid JDBC cancellation response")),
|
||||
}
|
||||
}
|
||||
|
||||
impl JdbcPool {
|
||||
async fn connect(
|
||||
source: &DataSource,
|
||||
password: Option<&str>,
|
||||
driver: DbJdbcDriver,
|
||||
cache: PathBuf,
|
||||
) -> IdeResult<Self> {
|
||||
driver.validate()?;
|
||||
let mut fields = vec![
|
||||
"open".to_string(),
|
||||
driver.class_name,
|
||||
source.url.clone(),
|
||||
source.user.clone(),
|
||||
password.unwrap_or_default().to_owned(),
|
||||
source.read_only.to_string(),
|
||||
];
|
||||
for p in &source.properties {
|
||||
if p.name.eq_ignore_ascii_case("password") {
|
||||
return Err(IdeError::invalid("Enter the JDBC password in the password field"));
|
||||
}
|
||||
fields.extend([p.name.clone(), p.value.clone()]);
|
||||
}
|
||||
let bridge = tokio::task::spawn_blocking(move || Bridge::start(&cache, &driver.jars))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))??;
|
||||
let mut pool = Self {
|
||||
bridge: Mutex::new(Some(bridge)),
|
||||
closed: CancellationToken::new(),
|
||||
version: String::new(),
|
||||
identifier_quote: String::new(),
|
||||
};
|
||||
let args: Vec<_> = fields.iter().map(String::as_str).collect();
|
||||
let cancel = CancellationToken::new();
|
||||
let result = tokio::time::timeout(Duration::from_secs(30), pool.request(&args, "", &cancel))
|
||||
.await
|
||||
.map_err(|_| IdeError::new(ide_core::error::ErrorKind::TimedOut, "JDBC connection timed out"))??;
|
||||
let mut metadata = result.rows.into_iter().next().unwrap_or_default().into_iter();
|
||||
pool.version = metadata.next().flatten().unwrap_or_else(|| "Connected".into());
|
||||
pool.identifier_quote = metadata.next().flatten().unwrap_or_default().trim().into();
|
||||
Ok(pool)
|
||||
}
|
||||
|
||||
pub(crate) async fn close(&self) {
|
||||
self.closed.cancel();
|
||||
if let Some(bridge) = self.bridge.lock().await.take() {
|
||||
bridge.close().await;
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_closed(&self) -> bool {
|
||||
self.closed.is_cancelled()
|
||||
}
|
||||
|
||||
pub(crate) async fn query(
|
||||
&self,
|
||||
sql: &str,
|
||||
skip: usize,
|
||||
max: usize,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<QueryResult> {
|
||||
self.query_in_schema(sql, skip, max, cancel, None).await
|
||||
}
|
||||
|
||||
pub(crate) async fn query_in_schema(
|
||||
&self,
|
||||
sql: &str,
|
||||
skip: usize,
|
||||
max: usize,
|
||||
cancel: &CancellationToken,
|
||||
schema: Option<&str>,
|
||||
) -> IdeResult<QueryResult> {
|
||||
self.request(
|
||||
&["query", sql, &skip.to_string(), &max.min(i32::MAX as usize).to_string(), schema.unwrap_or_default()],
|
||||
sql,
|
||||
cancel,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
pub(crate) async fn page(
|
||||
&self,
|
||||
sql: &str,
|
||||
offset: u64,
|
||||
limit: u64,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<QueryResult> {
|
||||
self.request(&["page", sql, &offset.to_string(), &limit.min(i32::MAX as u64).to_string()], sql, cancel).await
|
||||
}
|
||||
|
||||
pub(crate) async fn metadata(&self, fields: &[&str]) -> IdeResult<Vec<Vec<Option<String>>>> {
|
||||
Ok(self.request(fields, "", &CancellationToken::new()).await?.rows)
|
||||
}
|
||||
|
||||
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let mut slot = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
() = self.closed.cancelled() => return Err(IdeError::invalid("JDBC connection is closed")),
|
||||
slot = self.bridge.lock() => slot,
|
||||
};
|
||||
let bridge = slot
|
||||
.as_mut()
|
||||
.ok_or_else(|| IdeError::invalid("JDBC connection is closed; reconnect to start a new session"))?;
|
||||
bridge.sequence = bridge.sequence.wrapping_add(1);
|
||||
let frame = encode(bridge.sequence, fields)?;
|
||||
let mut bridge = slot.take().expect("checked above");
|
||||
// Dropping an in-flight request must discard its process and partially consumed frame.
|
||||
let interrupted = self.closed.clone().drop_guard();
|
||||
let start = Instant::now();
|
||||
let response = tokio::select! {
|
||||
biased;
|
||||
() = self.closed.cancelled() => Err(IdeError::cancelled()),
|
||||
response = exchange(&mut bridge.input, &mut bridge.output, frame, cancel) => response,
|
||||
};
|
||||
let data = match response {
|
||||
Ok(data) => {
|
||||
*slot = Some(bridge);
|
||||
interrupted.disarm();
|
||||
data
|
||||
}
|
||||
Err(e) => {
|
||||
drop(bridge.stop);
|
||||
let _ = bridge.exited.await;
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
decode(&data.ok_or_else(IdeError::cancelled)?, sql, start.elapsed().as_secs_f64() * 1000.0)
|
||||
}
|
||||
}
|
||||
|
||||
fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
|
||||
let mut input = Cursor::new(data);
|
||||
fn bytes<const N: usize>(input: &mut Cursor<&[u8]>) -> IdeResult<[u8; N]> {
|
||||
let mut buf = [0; N];
|
||||
Read::read_exact(input, &mut buf)?;
|
||||
Ok(buf)
|
||||
}
|
||||
fn flag(input: &mut Cursor<&[u8]>) -> IdeResult<bool> {
|
||||
match bytes::<1>(input)? {
|
||||
[0] => Ok(false),
|
||||
[1] => Ok(true),
|
||||
_ => Err(IdeError::invalid("Invalid JDBC flag")),
|
||||
}
|
||||
}
|
||||
fn field(input: &mut Cursor<&[u8]>) -> IdeResult<Option<String>> {
|
||||
let n = i32::from_be_bytes(bytes(input)?);
|
||||
if n == -1 {
|
||||
return Ok(None);
|
||||
}
|
||||
let start = input.position() as usize;
|
||||
let end = start
|
||||
.checked_add(n as usize)
|
||||
.filter(|end| *end <= input.get_ref().len())
|
||||
.ok_or_else(|| IdeError::invalid("Invalid JDBC field length"))?;
|
||||
let value = String::from_utf8_lossy(&input.get_ref()[start..end]).into_owned();
|
||||
input.set_position(end as u64);
|
||||
Ok(Some(value))
|
||||
}
|
||||
if !flag(&mut input)? {
|
||||
return Err(IdeError::invalid(field(&mut input)?.unwrap_or_else(|| "JDBC request failed".into())));
|
||||
}
|
||||
let count = u32::from_be_bytes(bytes(&mut input)?) as usize;
|
||||
if count > data.len() / 8 {
|
||||
return Err(IdeError::invalid("Invalid JDBC column count"));
|
||||
}
|
||||
let mut columns = Vec::new();
|
||||
for _ in 0..count {
|
||||
columns.push(ResultColumn {
|
||||
name: field(&mut input)?.unwrap_or_default(),
|
||||
type_name: field(&mut input)?.unwrap_or_default(),
|
||||
});
|
||||
}
|
||||
let mut rows = vec![];
|
||||
while flag(&mut input)? {
|
||||
if count == 0 {
|
||||
return Err(IdeError::invalid("JDBC returned a row with no columns"));
|
||||
}
|
||||
rows.push((0..count).map(|_| field(&mut input)).collect::<IdeResult<_>>()?);
|
||||
}
|
||||
let has_more = flag(&mut input)?;
|
||||
let affected = i64::from_be_bytes(bytes(&mut input)?);
|
||||
if input.position() != data.len() as u64 {
|
||||
return Err(IdeError::invalid("Invalid trailing JDBC response data"));
|
||||
}
|
||||
Ok(QueryResult {
|
||||
statement: sql.into(),
|
||||
columns,
|
||||
rows,
|
||||
has_more,
|
||||
affected: (affected >= 0).then_some(affected as f64),
|
||||
elapsed_ms,
|
||||
execution_ms: elapsed_ms,
|
||||
})
|
||||
}
|
||||
|
||||
impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let schemas = self.schemas(id).await?;
|
||||
for schema in &schemas {
|
||||
for table in self.tables(id, schema).await? {
|
||||
tables.push(crate::CompletionTable {
|
||||
schema: schema.clone(),
|
||||
name: table.name,
|
||||
kind: table.kind,
|
||||
columns: vec![],
|
||||
});
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(crate::CompletionModel {
|
||||
default_schema: pool
|
||||
.metadata(&["namespace"])
|
||||
.await?
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.next()
|
||||
.unwrap_or_default(),
|
||||
tables,
|
||||
foreign_keys: vec![],
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn frame_codec_checks_both_16_mib_boundaries() {
|
||||
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
|
||||
let mut field = "x".repeat(LIMIT - 16);
|
||||
assert_eq!(encode(1, &[&field]).unwrap().len(), LIMIT);
|
||||
field.push('x');
|
||||
assert!(encode(1, &[&field]).is_err());
|
||||
let mut framed = vec![0u8; LIMIT + 4];
|
||||
framed[..4].copy_from_slice(&(LIMIT as u32).to_be_bytes());
|
||||
assert_eq!(read_frame(&mut framed.as_slice()).await.unwrap().len(), LIMIT);
|
||||
assert!(read_frame(&mut &((LIMIT + 1) as u32).to_be_bytes()[..]).await.is_err());
|
||||
assert!(read_frame(&mut &[0, 0, 0, 2, 1u8][..]).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancel_drains_partial_replies_in_either_order() {
|
||||
for ack_first in [true, false] {
|
||||
let (mut input, mut peer_input) = tokio::io::duplex(1);
|
||||
let (mut output, mut peer_output) = tokio::io::duplex(1);
|
||||
let cancel = CancellationToken::new();
|
||||
let frame = encode(42, &["query"]).unwrap();
|
||||
let peer = async {
|
||||
let mut request = vec![0; frame.len()];
|
||||
peer_input.read_exact(&mut request).await.unwrap();
|
||||
assert_eq!(request, frame);
|
||||
// The one-byte pipe forces the reader to consume part of the header before Cancel.
|
||||
peer_output.write_all(&[0, 0]).await.unwrap();
|
||||
cancel.cancel();
|
||||
let mut stop = [0; 12];
|
||||
peer_input.read_exact(&mut stop).await.unwrap();
|
||||
assert_eq!(&stop[..8], &42u64.to_be_bytes());
|
||||
assert_eq!(&stop[8..], &[0; 4]);
|
||||
let frames = if ack_first { [0, 0, 0, 0, 0, 1, 0] } else { [0, 1, 1, 0, 0, 0, 0] };
|
||||
peer_output.write_all(&frames).await.unwrap();
|
||||
};
|
||||
let (result, ()) = tokio::join!(exchange(&mut input, &mut output, frame.clone(), &cancel), peer);
|
||||
assert_eq!(result.unwrap(), (!ack_first).then(|| vec![1]));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn exchange_rejects_unexpected_acknowledgements() {
|
||||
let cancel = CancellationToken::new();
|
||||
let mut sink = tokio::io::sink();
|
||||
let mut reply = &[0, 0, 0, 1, 1u8][..];
|
||||
assert_eq!(
|
||||
exchange(&mut sink, &mut reply, encode(1, &["query"]).unwrap(), &cancel).await.unwrap(),
|
||||
Some(vec![1])
|
||||
);
|
||||
for cancelled in [false, true] {
|
||||
if cancelled {
|
||||
cancel.cancel();
|
||||
}
|
||||
let mut duplicate_ack = &[0u8; 8][..];
|
||||
assert!(exchange(&mut sink, &mut duplicate_ack, encode(1, &["query"]).unwrap(), &cancel).await.is_err());
|
||||
}
|
||||
let (mut peer, mut output) = tokio::io::duplex(4);
|
||||
peer.write_u32(0).await.unwrap();
|
||||
let error = exchange(&mut sink, &mut output, encode(1, &["query"]).unwrap(), &cancel).await.unwrap_err();
|
||||
assert_eq!(error.message, cancel_timeout().message);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn result_codec_preserves_null_and_rejects_incomplete_frames() {
|
||||
let mut frame =
|
||||
vec![1, 0, 0, 0, 1, 0, 0, 0, 1, b'n', 0, 0, 0, 3, b'i', b'n', b't', 1, 255, 255, 255, 255, 0, 0];
|
||||
frame.extend_from_slice(&(-1i64).to_be_bytes());
|
||||
let result = decode(&frame, "select", 0.).unwrap();
|
||||
assert_eq!(result.columns[0].name, "n");
|
||||
assert_eq!(result.rows, [vec![None]]);
|
||||
for end in 0..frame.len() {
|
||||
assert!(decode(&frame[..end], "", 0.).is_err());
|
||||
}
|
||||
frame.push(0);
|
||||
assert!(decode(&frame, "", 0.).is_err());
|
||||
assert!(decode(&[2], "", 0.).is_err());
|
||||
}
|
||||
}
|
||||
@@ -4,8 +4,6 @@
|
||||
|
||||
pub mod catalog;
|
||||
mod clickhouse;
|
||||
mod jdbc;
|
||||
pub use jdbc::{DbJdbcDriver, jdbc_driver_classes};
|
||||
pub mod conn;
|
||||
pub mod history;
|
||||
mod oracle;
|
||||
@@ -341,7 +339,7 @@ fn group_foreign_keys(rows: Vec<Vec<Option<String>>>, tables: &[CompletionTable]
|
||||
/// never contain `:`.
|
||||
/// Snowflake is HTTPS to a named host: a tunnel's local end cannot pass its certificate check.
|
||||
fn tunneled(driver: DbDriver) -> bool {
|
||||
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake | DbDriver::Jdbc)
|
||||
!matches!(driver, DbDriver::Sqlite | DbDriver::Snowflake)
|
||||
}
|
||||
|
||||
/// The database host and port the SSH host forwards to.
|
||||
@@ -761,7 +759,7 @@ impl DbManager {
|
||||
};
|
||||
let (target, tunnel) = self.endpoint(source, ssh_secret, false).await?;
|
||||
self.restore_sso(source).await;
|
||||
let connected = self.open_pool(&target, password.as_deref(), true).await;
|
||||
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
|
||||
self.keep_sso(source).await;
|
||||
let pool = connected.map_err(|e| {
|
||||
through_tunnel(
|
||||
@@ -770,13 +768,7 @@ impl DbManager {
|
||||
tunnel.is_some().then(|| self.ssh_label(source.ssh.as_ref().expect("tunneled"))).as_deref(),
|
||||
)
|
||||
})?;
|
||||
if let Pool::Jdbc(p) = &pool {
|
||||
let version = p.version.clone();
|
||||
pool.close().await;
|
||||
return Ok(version);
|
||||
}
|
||||
let version = match source.driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC uses driver metadata"),
|
||||
DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",
|
||||
DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",
|
||||
DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",
|
||||
@@ -869,7 +861,7 @@ impl DbManager {
|
||||
let password = self.password(&source).await;
|
||||
let (target, tunnel) = self.endpoint(&source, None, true).await?;
|
||||
self.restore_sso(&source).await;
|
||||
let connected = self.open_pool(&target, password.as_deref(), false).await;
|
||||
let connected = Pool::connect(&target, password.as_deref(), Some(&self.root)).await;
|
||||
self.keep_sso(&source).await;
|
||||
let pool = match connected {
|
||||
Ok(p) => Arc::new(p),
|
||||
@@ -924,37 +916,6 @@ impl DbManager {
|
||||
self.tunnels.lock().remove(id);
|
||||
}
|
||||
|
||||
/// Creates a database on the server of data source `id` by running `statement` on the data
|
||||
/// source's own database, after closing the IDE's connections to `template`, the database
|
||||
/// the server copies (PostgreSQL and SQL Server refuse to copy one that has sessions).
|
||||
pub async fn create_database(&self, id: &str, template: &str, statement: &str) -> IdeResult<()> {
|
||||
let id = split_target(id).0;
|
||||
if self.source(id)?.read_only {
|
||||
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
|
||||
}
|
||||
self.disconnect(&format!("{id}:{template}")).await;
|
||||
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
|
||||
self.remember_statement(id, statement);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Drops `database` of the server of data source `id` by running `statement` on the data
|
||||
/// source's own database, after closing the IDE's connections to `database`.
|
||||
/// Refuses the database the data source connects to and read-only data sources.
|
||||
pub async fn drop_database(&self, id: &str, database: &str, statement: &str) -> IdeResult<()> {
|
||||
let id = split_target(id).0;
|
||||
if self.source(id)?.read_only {
|
||||
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
|
||||
}
|
||||
if self.databases(id).await?.current == database {
|
||||
return Err(IdeError::invalid(format!("the data source connects to {database}; it cannot drop it")));
|
||||
}
|
||||
self.disconnect(&format!("{id}:{database}")).await;
|
||||
self.pool(id).await?.execute(statement, 0, &CancellationToken::new()).await?;
|
||||
self.remember_statement(id, statement);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The databases of the server of data source `id` (PostgreSQL), the connected one first.
|
||||
pub async fn databases(&self, id: &str) -> IdeResult<Databases> {
|
||||
let id = split_target(id).0;
|
||||
@@ -1079,10 +1040,7 @@ impl DbManager {
|
||||
if let Pool::Snowflake(p) = &*pool {
|
||||
return snowflake::meta::schemas(p, system).await;
|
||||
}
|
||||
let rows = match &*pool {
|
||||
Pool::Jdbc(p) => p.metadata(&["schemas"]).await?,
|
||||
_ => pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?,
|
||||
};
|
||||
let rows = pool.rows(sql::schemas(pool.driver(), system), MAX_META_ROWS).await?;
|
||||
Ok(rows.into_iter().filter_map(|r| r.into_iter().next().flatten()).collect())
|
||||
}
|
||||
|
||||
@@ -1091,10 +1049,7 @@ impl DbManager {
|
||||
if let Pool::Snowflake(p) = &*pool {
|
||||
return snowflake::meta::tables(p, schema).await;
|
||||
}
|
||||
let rows = match &*pool {
|
||||
Pool::Jdbc(p) => p.metadata(&["tables", schema]).await?,
|
||||
_ => pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?,
|
||||
};
|
||||
let rows = pool.rows(&sql::tables(pool.driver(), schema), MAX_META_ROWS).await?;
|
||||
Ok(rows
|
||||
.into_iter()
|
||||
.filter_map(|r| {
|
||||
@@ -1111,11 +1066,9 @@ impl DbManager {
|
||||
return snowflake::meta::table_details(p, schema, table).await;
|
||||
}
|
||||
let driver = pool.driver();
|
||||
let rows = match &*pool {
|
||||
Pool::Jdbc(p) => p.metadata(&["columns", schema, table]).await?,
|
||||
_ => pool.rows(&sql::columns(driver, schema, table), MAX_META_ROWS).await?,
|
||||
};
|
||||
let columns = rows
|
||||
let columns = pool
|
||||
.rows(&sql::columns(driver, schema, table), MAX_META_ROWS)
|
||||
.await?
|
||||
.into_iter()
|
||||
.filter_map(|r| {
|
||||
let mut it = r.into_iter();
|
||||
@@ -1127,9 +1080,6 @@ impl DbManager {
|
||||
Some(ColumnInfo { name, data_type, nullable, default, primary_key })
|
||||
})
|
||||
.collect();
|
||||
if driver == DbDriver::Jdbc {
|
||||
return Ok(TableDetails { columns, indexes: vec![], foreign_keys: vec![], triggers: vec![] });
|
||||
}
|
||||
let mut indexes: Vec<IndexInfo> = Vec::new();
|
||||
for r in pool.rows(&sql::indexes(driver, schema, table), MAX_META_ROWS).await? {
|
||||
let mut it = r.into_iter();
|
||||
@@ -1290,7 +1240,6 @@ impl DbManager {
|
||||
rows.into_iter().filter_map(|r| r.into_iter().nth(i).flatten()).collect()
|
||||
};
|
||||
match driver {
|
||||
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC sources do not provide vendor-specific DDL")),
|
||||
DbDriver::Sqlite => {
|
||||
let stmts = cells(pool.rows(&sql::sqlite_ddl(schema, name), MAX_META_ROWS).await?, 0);
|
||||
if stmts.is_empty() {
|
||||
@@ -1415,7 +1364,6 @@ impl DbManager {
|
||||
let driver = pool.driver();
|
||||
let mut tables: Vec<CompletionTable> = Vec::new();
|
||||
let rows = match &*pool {
|
||||
Pool::Jdbc(p) => return self.jdbc_completion(id, p).await,
|
||||
Pool::Snowflake(p) => {
|
||||
tables = snowflake::meta::completion(p).await?;
|
||||
Vec::new()
|
||||
@@ -1536,9 +1484,6 @@ impl DbManager {
|
||||
schema: Option<&str>,
|
||||
) -> IdeResult<Vec<PlanNode>> {
|
||||
let driver = self.pool(id).await?.driver();
|
||||
if driver == DbDriver::Jdbc {
|
||||
return Err(IdeError::invalid("Custom JDBC execution plans are unsupported"));
|
||||
}
|
||||
if driver == DbDriver::Oracle {
|
||||
// EXPLAIN PLAN writes PLAN_TABLE; the plan is read (and cleaned up) separately.
|
||||
let plan_id = format!(
|
||||
@@ -1578,9 +1523,6 @@ impl DbManager {
|
||||
schema: Option<&str>,
|
||||
) -> IdeResult<QueryResult> {
|
||||
let pool = self.pool(id).await?;
|
||||
if let Pool::Jdbc(p) = &*pool {
|
||||
return p.query_in_schema(statement, skip, max_rows, cancel, schema).await;
|
||||
}
|
||||
let session = self.sessions.lock().get(id).cloned();
|
||||
let Some(session) = session else {
|
||||
if schema.is_none() {
|
||||
@@ -1622,9 +1564,6 @@ impl DbManager {
|
||||
/// Switches `id` between auto-commit and manual commit. Leaving manual
|
||||
/// mode rolls back what was not committed.
|
||||
pub async fn set_manual_commit(&self, id: &str, manual: bool) -> IdeResult<()> {
|
||||
if manual && self.source(id)?.driver == DbDriver::Jdbc {
|
||||
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
|
||||
}
|
||||
if manual {
|
||||
if self.source(id)?.driver == DbDriver::Clickhouse {
|
||||
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
|
||||
@@ -1644,9 +1583,6 @@ impl DbManager {
|
||||
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Clickhouse) {
|
||||
return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
|
||||
}
|
||||
if self.source(id).is_ok_and(|s| s.driver == DbDriver::Jdbc) {
|
||||
return Err(IdeError::invalid("Custom JDBC manual transactions are unsupported"));
|
||||
}
|
||||
let session = self.sessions.lock().get(id).cloned();
|
||||
let Some(session) = session else { return Ok(()) };
|
||||
let mut held = session.lock().await;
|
||||
@@ -1682,22 +1618,8 @@ impl DbManager {
|
||||
) -> IdeResult<TablePage> {
|
||||
let details = self.table_details(id, schema, table).await?;
|
||||
let pool = self.pool(id).await?;
|
||||
let mut result = if let Pool::Jdbc(p) = &*pool {
|
||||
let q = &p.identifier_quote;
|
||||
let names = [schema, table].into_iter().chain(sort.iter().map(|k| k.column.as_str()));
|
||||
if q.is_empty()
|
||||
&& names.into_iter().any(|name| !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'))
|
||||
{
|
||||
return Err(IdeError::invalid("This JDBC driver cannot quote the selected identifier"));
|
||||
}
|
||||
let quote = |s: &str| format!("{q}{}{q}", s.replace(q, &format!("{q}{q}")));
|
||||
let name = if schema.is_empty() { quote(table) } else { format!("{}.{}", quote(schema), quote(table)) };
|
||||
let sql = sql::table_select(&name, filter, sort, quote);
|
||||
p.page(&sql, offset, limit, cancel).await?
|
||||
} else {
|
||||
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
|
||||
pool.execute(&sql, limit as usize, cancel).await?
|
||||
};
|
||||
let sql = sql::table_page(pool.driver(), schema, table, filter, sort, offset, limit);
|
||||
let mut result = pool.execute(&sql, limit as usize, cancel).await?;
|
||||
if result.columns.is_empty() {
|
||||
result.columns = details
|
||||
.columns
|
||||
@@ -1710,11 +1632,7 @@ impl DbManager {
|
||||
|
||||
/// Applies the table editor's pending changes in one transaction.
|
||||
pub async fn apply_edits(&self, id: &str, schema: &str, table: &str, edits: &[DbRowEdit]) -> IdeResult<u64> {
|
||||
let source = self.source(id)?;
|
||||
if source.read_only {
|
||||
return Err(IdeError::new(ErrorKind::PermissionDenied, "the data source is read-only"));
|
||||
}
|
||||
if source.driver == DbDriver::Clickhouse {
|
||||
if self.source(id)?.driver == DbDriver::Clickhouse {
|
||||
return Err(IdeError::invalid("ClickHouse table editing is unsupported"));
|
||||
}
|
||||
let pool = self.pool(id).await?;
|
||||
|
||||
@@ -36,7 +36,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {
|
||||
DbDriver::Sqlite => format!("EXPLAIN QUERY PLAN {s}"),
|
||||
DbDriver::Postgres => format!("EXPLAIN (FORMAT JSON) {s}"),
|
||||
DbDriver::Clickhouse => format!("EXPLAIN json = 1 {s}"),
|
||||
DbDriver::Mysql | DbDriver::Jdbc => format!("EXPLAIN {s}"),
|
||||
DbDriver::Mysql => format!("EXPLAIN {s}"),
|
||||
DbDriver::SqlServer => format!("SET SHOWPLAN_TEXT ON; {s}"),
|
||||
DbDriver::Oracle => format!("EXPLAIN PLAN FOR {s}"),
|
||||
DbDriver::Snowflake => format!("EXPLAIN USING TABULAR {s}"),
|
||||
@@ -77,7 +77,6 @@ pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>>
|
||||
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
|
||||
Ok(mysql(&names, &result.rows))
|
||||
}
|
||||
DbDriver::Jdbc => Err(IdeError::invalid("Custom JDBC execution plans are unsupported")),
|
||||
DbDriver::SqlServer => Ok(Vec::new()),
|
||||
DbDriver::Snowflake => {
|
||||
let names: Vec<&str> = result.columns.iter().map(|c| c.name.as_str()).collect();
|
||||
|
||||
@@ -23,13 +23,12 @@ pub enum DbDriver {
|
||||
/// Oracle Database (pure-Rust thin driver, no client library).
|
||||
Oracle,
|
||||
Snowflake,
|
||||
Jdbc,
|
||||
}
|
||||
|
||||
impl DbDriver {
|
||||
pub fn default_port(self) -> Option<u16> {
|
||||
match self {
|
||||
DbDriver::Sqlite | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite => None,
|
||||
DbDriver::Postgres => Some(5432),
|
||||
DbDriver::Mysql => Some(3306),
|
||||
DbDriver::SqlServer => Some(1433),
|
||||
@@ -192,9 +191,6 @@ pub struct DataSource {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub driver: DbDriver,
|
||||
/// An app-wide driver profile id; classpaths never come from a project.
|
||||
#[serde(skip_serializing_if = "String::is_empty")]
|
||||
pub jdbc_driver: String,
|
||||
pub host: String,
|
||||
pub port: Option<u16>,
|
||||
pub database: String,
|
||||
@@ -241,7 +237,6 @@ impl Default for DataSource {
|
||||
id: String::new(),
|
||||
name: String::new(),
|
||||
driver: DbDriver::Sqlite,
|
||||
jdbc_driver: String::new(),
|
||||
host: "localhost".into(),
|
||||
port: None,
|
||||
database: String::new(),
|
||||
@@ -395,12 +390,6 @@ impl DataSource {
|
||||
/// database, user, SSL and driver properties come from the URL (properties
|
||||
/// of the Advanced tab still apply after the URL's).
|
||||
pub fn resolved(&self) -> IdeResult<DataSource> {
|
||||
if self.driver == DbDriver::Jdbc {
|
||||
if !self.url.starts_with("jdbc:") {
|
||||
return Err(IdeError::invalid("Enter a JDBC URL starting with jdbc:"));
|
||||
}
|
||||
return Ok(self.clone());
|
||||
}
|
||||
if !self.url_only {
|
||||
return Ok(self.clone());
|
||||
}
|
||||
@@ -487,7 +476,7 @@ impl DataSource {
|
||||
|
||||
/// The password written in the URL of a [`DataSource::url_only`] data source.
|
||||
pub fn url_password(&self) -> Option<String> {
|
||||
if self.driver == DbDriver::Jdbc || !self.url_only {
|
||||
if !self.url_only {
|
||||
return None;
|
||||
}
|
||||
parse_url(&self.url).ok()?.password
|
||||
@@ -502,11 +491,7 @@ struct SourcesFile {
|
||||
|
||||
/// The project's data sources.
|
||||
pub fn load(root: &Path) -> IdeResult<Vec<DataSource>> {
|
||||
let mut sources = read(&project_dir::path(root, FILE))?;
|
||||
for source in &mut sources {
|
||||
source.global = false;
|
||||
}
|
||||
Ok(sources)
|
||||
read(&project_dir::path(root, FILE))
|
||||
}
|
||||
|
||||
/// Saves the project's data sources.
|
||||
|
||||
@@ -70,7 +70,6 @@ pub fn sqlserver_databases() -> &'static str {
|
||||
|
||||
pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Sqlite => "SELECT name FROM pragma_database_list WHERE name <> 'temp' ORDER BY seq",
|
||||
DbDriver::Clickhouse if system => "SELECT name FROM system.databases ORDER BY name",
|
||||
DbDriver::Clickhouse => {
|
||||
@@ -115,7 +114,6 @@ pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
|
||||
/// Rows: `name, kind` where kind is `table`, `view` or `materialized view`.
|
||||
pub fn tables(driver: DbDriver, schema: &str) -> String {
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => format!(
|
||||
"SELECT name, CASE engine WHEN 'View' THEN 'view' WHEN 'MaterializedView' THEN 'materialized view' \
|
||||
WHEN 'WindowView' THEN 'view' ELSE 'table' END FROM system.tables \
|
||||
@@ -166,7 +164,6 @@ const SNOWFLAKE_TYPE: &str = "CASE WHEN data_type = 'NUMBER' THEN 'NUMBER(' || n
|
||||
pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => format!(
|
||||
"SELECT name, type, CASE WHEN startsWith(type, 'Nullable(') \
|
||||
OR startsWith(type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, \
|
||||
@@ -228,7 +225,6 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => format!(
|
||||
"SELECT * FROM (SELECT 'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression \
|
||||
FROM system.tables WHERE database = {s} AND name = {t} AND primary_key != '' \
|
||||
@@ -273,7 +269,6 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
/// for SQL completion, grouped by table in column order.
|
||||
pub fn completion_columns(driver: DbDriver) -> &'static str {
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => {
|
||||
"SELECT c.database, c.table, CASE t.engine WHEN 'View' THEN 'view' \
|
||||
WHEN 'MaterializedView' THEN 'materialized view' WHEN 'WindowView' THEN 'view' ELSE 'table' END, \
|
||||
@@ -362,7 +357,6 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
|
||||
/// when the key references the primary key implicitly.
|
||||
pub fn foreign_keys(driver: DbDriver) -> &'static str {
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => "SELECT '', '', '', '', '', '', '' WHERE 0",
|
||||
DbDriver::Snowflake => "SELECT '', '', '', '', '', '', '' WHERE 1 = 0",
|
||||
DbDriver::Sqlite => {
|
||||
@@ -415,7 +409,6 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
|
||||
pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse | DbDriver::Snowflake => foreign_keys(driver).to_owned(),
|
||||
DbDriver::Sqlite => format!(
|
||||
"SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
|
||||
@@ -439,7 +432,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
|
||||
pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
match driver {
|
||||
DbDriver::Clickhouse => Some("SELECT currentDatabase()"),
|
||||
DbDriver::Sqlite | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite => None,
|
||||
DbDriver::Postgres => Some("SELECT current_schema()"),
|
||||
DbDriver::Mysql => Some("SELECT DATABASE()"),
|
||||
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
|
||||
@@ -453,7 +446,7 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
|
||||
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
|
||||
match driver {
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse => None,
|
||||
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
|
||||
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
|
||||
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
|
||||
@@ -469,13 +462,17 @@ pub struct SortKey {
|
||||
pub descending: bool,
|
||||
}
|
||||
|
||||
pub(crate) fn table_select(
|
||||
qualified_name: &str,
|
||||
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
|
||||
pub fn table_page(
|
||||
driver: DbDriver,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
filter: Option<&str>,
|
||||
sort: &[SortKey],
|
||||
quote: impl Fn(&str) -> String,
|
||||
offset: u64,
|
||||
limit: u64,
|
||||
) -> String {
|
||||
let mut sql = format!("SELECT * FROM {}", qualified_name);
|
||||
let mut sql = format!("SELECT * FROM {}", qualified(driver, schema, table));
|
||||
if let Some(f) = filter.map(str::trim).filter(|f| !f.is_empty()) {
|
||||
let mut f = f.strip_prefix("WHERE ").or_else(|| f.strip_prefix("where ")).unwrap_or(f);
|
||||
if let Some(i) = f.find(';') {
|
||||
@@ -487,24 +484,12 @@ pub(crate) fn table_select(
|
||||
}
|
||||
}
|
||||
if !sort.is_empty() {
|
||||
let keys: Vec<String> =
|
||||
sort.iter().map(|k| format!("{}{}", quote(&k.column), if k.descending { " DESC" } else { "" })).collect();
|
||||
let keys: Vec<String> = sort
|
||||
.iter()
|
||||
.map(|k| format!("{}{}", quote_ident(driver, &k.column), if k.descending { " DESC" } else { "" }))
|
||||
.collect();
|
||||
sql.push_str(&format!(" ORDER BY {}", keys.join(", ")));
|
||||
}
|
||||
sql
|
||||
}
|
||||
|
||||
/// One page of a table: `limit + 1` rows so the caller knows whether more exist.
|
||||
pub fn table_page(
|
||||
driver: DbDriver,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
filter: Option<&str>,
|
||||
sort: &[SortKey],
|
||||
offset: u64,
|
||||
limit: u64,
|
||||
) -> String {
|
||||
let mut sql = table_select(&qualified(driver, schema, table), filter, sort, |name| quote_ident(driver, name));
|
||||
if driver == DbDriver::SqlServer {
|
||||
if sort.is_empty() {
|
||||
sql.push_str(" ORDER BY (SELECT 1)");
|
||||
@@ -550,9 +535,6 @@ fn where_key(driver: DbDriver, key: &[CellValue]) -> String {
|
||||
/// The DML statement for `edit`. Values are written as quoted literals, which
|
||||
/// every supported database coerces to the column type.
|
||||
pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowEdit) -> Result<String, String> {
|
||||
if driver == DbDriver::Jdbc {
|
||||
return Err("Custom JDBC table editing is unsupported".into());
|
||||
}
|
||||
if driver == DbDriver::Clickhouse {
|
||||
return Err("ClickHouse table editing is unsupported: primary keys do not uniquely identify rows and edits require transactions".into());
|
||||
}
|
||||
@@ -649,7 +631,6 @@ pub fn postgres_ddl_indexes(oid: u32) -> String {
|
||||
pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {
|
||||
let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
|
||||
match driver {
|
||||
DbDriver::Jdbc => unreachable!("JDBC introspection uses DatabaseMetaData"),
|
||||
DbDriver::Clickhouse => "SELECT '', '', '' WHERE 0".to_owned(),
|
||||
DbDriver::Snowflake => "SELECT '', '', '' WHERE 1 = 0".to_owned(),
|
||||
DbDriver::Sqlite => format!(
|
||||
@@ -710,7 +691,7 @@ pub fn postgres_legacy(sql: &str) -> Option<String> {
|
||||
pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
|
||||
let s = quote_literal(driver, schema);
|
||||
match driver {
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse => None,
|
||||
// Functions of extensions are left out, as in IDEA.
|
||||
DbDriver::Postgres => Some(format!(
|
||||
"SELECT p.proname, CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END, \
|
||||
|
||||
@@ -1,215 +0,0 @@
|
||||
use ide_core::{CancellationToken, IdeResult};
|
||||
use ide_db::{DataSource, DbDriver, DbJdbcDriver, DbManager, SortKey};
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
fn manager(dir: &Path) -> DbManager {
|
||||
let ssh = Arc::new(ide_ssh::SshManager::new(dir.join("ssh.json")));
|
||||
DbManager::new(dir.join("project"), dir.join("passwords.json"), dir.join("history.json"), ssh)
|
||||
.with_global_sources(dir.join("global"))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn jdbc_profiles_persist_and_project_files_cannot_start_drivers() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let jar = tmp.path().join("fixture.jar");
|
||||
std::fs::write(&jar, [])?;
|
||||
let db = manager(tmp.path());
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Test".into(),
|
||||
jars: vec![jar.display().to_string()],
|
||||
class_name: "test.Driver".into(),
|
||||
url_template: "jdbc:test:".into(),
|
||||
})?;
|
||||
let reopened = manager(tmp.path());
|
||||
assert_eq!(reopened.jdbc_drivers()?[0].class_name, "test.Driver");
|
||||
let source = DataSource {
|
||||
id: "local".into(),
|
||||
name: "local".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: "jdbc:test:".into(),
|
||||
..Default::default()
|
||||
};
|
||||
reopened.save_sources(vec![source.clone()]).await?;
|
||||
let denied = reopened.pool("local").await.err().expect("project JDBC requires explicit approval");
|
||||
assert!(denied.message.contains("Review this project"));
|
||||
let readonly = DataSource { read_only: true, ..source.clone() };
|
||||
reopened.save_sources(vec![readonly]).await?;
|
||||
let err = reopened.apply_edits("local", "main", "sample", &[]).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied);
|
||||
reopened.approve_jdbc_source(&source)?;
|
||||
let mut changed = source.clone();
|
||||
changed.url.push_str("changed");
|
||||
reopened.save_sources(vec![changed]).await?;
|
||||
assert!(reopened.pool("local").await.err().unwrap().message.contains("Review this project"));
|
||||
let mut global = source;
|
||||
global.global = true;
|
||||
reopened.save_sources(vec![global]).await?;
|
||||
assert!(reopened.remove_jdbc_driver("fixture").is_err());
|
||||
reopened.save_sources(vec![]).await?;
|
||||
reopened.remove_jdbc_driver("fixture")?;
|
||||
assert!(manager(tmp.path()).jdbc_drivers()?.is_empty());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires DUCKDB_JDBC_JAR and a local Java 17+ runtime"]
|
||||
async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
let jar = std::env::var("DUCKDB_JDBC_JAR").expect("DUCKDB_JDBC_JAR");
|
||||
assert_eq!(ide_db::jdbc_driver_classes(std::slice::from_ref(&jar))?, ["org.duckdb.DuckDBDriver"]);
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "duck".into(),
|
||||
name: "DuckDB".into(),
|
||||
jars: vec![jar],
|
||||
class_name: "org.duckdb.DuckDBDriver".into(),
|
||||
url_template: "jdbc:duckdb:".into(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "DuckDB".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
jdbc_driver: "duck".into(),
|
||||
url: "jdbc:duckdb:local.duckdb".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(db.test(&source, None, None).await?.to_lowercase().contains("duckdb"));
|
||||
db.save_sources(vec![source]).await?;
|
||||
let db = manager(tmp.path());
|
||||
let c = CancellationToken::new();
|
||||
db.execute("test", "create table items(id int primary key, label varchar)", 1, &c).await?;
|
||||
db.execute("test", "insert into items values (1, NULL), (2, 'row')", 1, &c).await?;
|
||||
assert!(db.schemas("test").await?.iter().any(|v| v == "main"));
|
||||
assert!(db.tables("test", "main").await?.iter().any(|v| v.name == "items"));
|
||||
let details = db.table_details("test", "main", "items").await?;
|
||||
assert_eq!(details.columns.len(), 2);
|
||||
let result = db.execute("test", "select id, label from items order by id", 1, &c).await?;
|
||||
assert!(result.has_more);
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
|
||||
assert_eq!(result.columns[1].name, "label");
|
||||
assert_eq!(db.completion("test").await?.default_schema, "main");
|
||||
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
|
||||
let stop = CancellationToken::new();
|
||||
let (cancelled, ()) =
|
||||
tokio::join!(db.execute("test", "select sum(sin(i)) from range(1000000000) t(i)", 1, &stop), async {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
stop.cancel();
|
||||
},);
|
||||
assert_eq!(cancelled.unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);
|
||||
let marker = db.execute("test", "select id from session_marker", 1, &c).await?;
|
||||
assert_eq!(marker.rows, [vec![Some("42".into())]]);
|
||||
let sort = [SortKey { column: "id".into(), descending: false }];
|
||||
let first = db.table_page("test", "main", "items", None, &sort, 0, 1, &c).await?.result;
|
||||
assert_eq!(first.rows, result.rows);
|
||||
assert!(first.has_more);
|
||||
let last = db.table_page("test", "main", "items", None, &sort, 1, 1, &c).await?.result;
|
||||
assert_eq!(last.rows, vec![vec![Some("2".into()), Some("row".into())]]);
|
||||
assert!(!last.has_more);
|
||||
let past = db.table_page("test", "main", "items", None, &sort, 2, 1, &c).await?.result;
|
||||
assert!(past.rows.is_empty() && !past.has_more);
|
||||
db.disconnect("test").await;
|
||||
let reopened = manager(tmp.path());
|
||||
assert_eq!(reopened.execute("test", "select count(*) from items", 1, &c).await?.rows, [vec![Some("2".into())]]);
|
||||
reopened.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires CLICKHOUSE_JDBC_CLASSPATH and a loopback ClickHouse fixture on CLICKHOUSE_JDBC_TEST_PORT"]
|
||||
async fn clickhouse_vendor_driver_reads_catalog_and_results() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
let jars: Vec<String> =
|
||||
std::env::split_paths(&std::env::var_os("CLICKHOUSE_JDBC_CLASSPATH").expect("CLICKHOUSE_JDBC_CLASSPATH"))
|
||||
.map(|p| p.display().to_string())
|
||||
.collect();
|
||||
let classes = ide_db::jdbc_driver_classes(&jars)?;
|
||||
assert_eq!(classes.first().map(String::as_str), Some("com.clickhouse.jdbc.ClickHouseDriver"));
|
||||
let port: u16 = std::env::var("CLICKHOUSE_JDBC_TEST_PORT").unwrap().parse().unwrap();
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "clickhouse".into(),
|
||||
name: "ClickHouse JDBC".into(),
|
||||
jars,
|
||||
class_name: "com.clickhouse.jdbc.ClickHouseDriver".into(),
|
||||
url_template: "jdbc:clickhouse://".into(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "ClickHouse JDBC".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
jdbc_driver: "clickhouse".into(),
|
||||
url: format!("jdbc:clickhouse://127.0.0.1:{port}/default"),
|
||||
user: "fixture".into(),
|
||||
read_only: true,
|
||||
..Default::default()
|
||||
};
|
||||
let password = "local-fixture";
|
||||
assert!(db.test(&source, Some(password.into()), None).await?.contains("ClickHouse"));
|
||||
db.approve_jdbc_source(&source)?;
|
||||
db.save_sources(vec![source]).await?;
|
||||
db.set_password("test", Some(password.into()), false).await?;
|
||||
assert!(db.schemas("test").await?.iter().any(|v| v == "system"));
|
||||
assert!(db.tables("test", "system").await?.iter().any(|v| v.name == "one"));
|
||||
let cols = db.table_details("test", "system", "one").await?.columns;
|
||||
assert!(cols.iter().any(|col| col.name == "dummy"));
|
||||
let r = db.execute("test", "SELECT number FROM numbers(3) ORDER BY number", 2, &CancellationToken::new()).await?;
|
||||
assert_eq!(r.rows.len(), 2);
|
||||
assert!(r.has_more);
|
||||
let c = CancellationToken::new();
|
||||
let page = db.table_page("test", "system", "one", None, &[], 0, 1, &c).await?.result;
|
||||
assert_eq!(page.rows.len(), 1);
|
||||
assert!(!page.has_more);
|
||||
let past = db.table_page("test", "system", "one", None, &[], 1, 1, &c).await?.result;
|
||||
assert!(past.rows.is_empty() && !past.has_more);
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
|
||||
async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
use std::time::Duration;
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
let started = tmp.path().join("started");
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Fixture".into(),
|
||||
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
|
||||
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
|
||||
url_template: String::new(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "Fixture".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
read_only: true,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: format!("jdbc:fixture:{}", started.display()),
|
||||
..Default::default()
|
||||
};
|
||||
db.test(&source, None, None).await?;
|
||||
db.save_sources(vec![source]).await?;
|
||||
let normal = CancellationToken::new();
|
||||
assert!(db.execute("test", "write", 1, &normal).await.unwrap_err().message.contains("read-only"));
|
||||
let stop = CancellationToken::new();
|
||||
let (result, ()) = tokio::time::timeout(Duration::from_secs(12), async {
|
||||
tokio::join!(db.execute("test", "ignore cancel", 1, &stop), async {
|
||||
while !started.is_file() {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
stop.cancel();
|
||||
})
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -230,44 +230,6 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
}
|
||||
|
||||
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
|
||||
#[tokio::test]
|
||||
async fn drops_a_database_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_drop_me", 0, &c).await?;
|
||||
db.execute("p", "CREATE DATABASE oi_drop_me TEMPLATE template0", 0, &c).await?;
|
||||
|
||||
// What the tree and a manual-commit console leave open on the database.
|
||||
db.schemas("p:oi_drop_me").await?;
|
||||
db.set_manual_commit("p:oi_drop_me", true).await?;
|
||||
db.execute("p:oi_drop_me", "SELECT 1", 1, &c).await?;
|
||||
|
||||
db.drop_database("p", "oi_drop_me", "drop database oi_drop_me").await?;
|
||||
assert!(!db.is_connected("p:oi_drop_me"));
|
||||
assert!(!db.databases("p").await?.names.iter().any(|n| n == "oi_drop_me"));
|
||||
|
||||
let current = db.databases("p").await?.current;
|
||||
let refused = db.drop_database("p", ¤t, &format!("drop database \"{current}\"")).await;
|
||||
assert!(refused.is_err());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn creates_a_database_from_a_template_the_ide_holds_connections_to() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_from_template", 0, &c).await?;
|
||||
db.schemas("p:template1").await?;
|
||||
|
||||
db.create_database("p", "template1", "create database oi_from_template").await?;
|
||||
assert!(!db.is_connected("p:template1"));
|
||||
assert!(db.databases("p").await?.names.iter().any(|n| n == "oi_from_template"));
|
||||
db.execute("p", "DROP DATABASE oi_from_template", 0, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
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();
|
||||
|
||||
@@ -95,44 +95,3 @@ async fn sqlserver_values_paging_transactions_and_cancellation() {
|
||||
task.await.unwrap();
|
||||
assert_eq!(pool.rows("SELECT 1", 1).await.unwrap()[0][0].as_deref(), Some("1"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sqlserver_creates_from_a_held_model_and_force_drops_a_held_database() {
|
||||
let Ok(server) = std::env::var("OPENIDEA_TEST_SQLSERVER") else { return };
|
||||
let mut parts = server.splitn(4, ':');
|
||||
let (host, port, user, password) = (
|
||||
parts.next().unwrap(),
|
||||
parts.next().unwrap().parse().unwrap(),
|
||||
parts.next().unwrap(),
|
||||
parts.next().unwrap_or(""),
|
||||
);
|
||||
let source = |database: &str| DataSource {
|
||||
id: "s".into(),
|
||||
name: "sqlserver".into(),
|
||||
driver: DbDriver::SqlServer,
|
||||
host: host.into(),
|
||||
port: Some(port),
|
||||
user: user.into(),
|
||||
database: database.into(),
|
||||
ssl: DbSslMode::Disable,
|
||||
..Default::default()
|
||||
};
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().to_path_buf();
|
||||
let ssh = std::sync::Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
|
||||
let db = ide_db::DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
|
||||
db.save_sources(vec![source("master")]).await.unwrap();
|
||||
db.set_password("s", Some(password.into()), false).await.unwrap();
|
||||
let name = format!("oi_force_drop_{}", std::process::id());
|
||||
// The tree's connection to `model` would keep SQL Server from copying it.
|
||||
db.schemas("s:model").await.unwrap();
|
||||
db.create_database("s", "model", &format!("create database {name};")).await.unwrap();
|
||||
assert!(!db.is_connected("s:model"));
|
||||
|
||||
let other = Pool::connect(&source(&name), Some(password), None).await.unwrap();
|
||||
let held = Held::acquire(&other).await.unwrap();
|
||||
let force = format!("alter database {name} set single_user with rollback immediate;\ndrop database {name};");
|
||||
db.drop_database("s", &name, &force).await.unwrap();
|
||||
assert!(!db.databases("s").await.unwrap().names.contains(&name));
|
||||
drop(held);
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -5,7 +5,6 @@
|
||||
//! Every function blocks; callers run them off the UI / command threads.
|
||||
|
||||
mod connection;
|
||||
mod engine;
|
||||
mod model;
|
||||
mod process;
|
||||
|
||||
@@ -115,11 +114,6 @@ fn failure(args: &[&str], stderr: &str, stdout: &str) -> IdeError {
|
||||
|
||||
/// Whether docker can be used right now.
|
||||
pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(available) = engine::availability(ep, Duration::from_secs(15))
|
||||
{
|
||||
return available;
|
||||
}
|
||||
let Ok(cmd) = command(ep, &["version", "--format", "{{json .}}"]) else {
|
||||
return DockerAvailability::NotInstalled;
|
||||
};
|
||||
@@ -131,11 +125,6 @@ pub fn availability(ep: &DockerEndpoint) -> DockerAvailability {
|
||||
|
||||
/// Availability plus containers, images, volumes and networks (listed in parallel).
|
||||
pub fn snapshot(ep: &DockerEndpoint) -> DockerSnapshot {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(listed) = engine::snapshot(ep, QUICK)
|
||||
{
|
||||
return listed;
|
||||
}
|
||||
let availability = availability(ep);
|
||||
let executable = docker_executable().map(|p| ide_core::ipc_path::to_ipc(&p));
|
||||
let mut snap = DockerSnapshot {
|
||||
@@ -213,11 +202,6 @@ pub fn container_op(ep: &DockerEndpoint, ids: &[String], op: ContainerOp) -> Ide
|
||||
if ids.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
if docker_executable().is_none()
|
||||
&& let Some(ran) = engine::container_op(ep, ids, op, LIFECYCLE)
|
||||
{
|
||||
return ran;
|
||||
}
|
||||
let mut args = vec!["container", op.verb()];
|
||||
args.extend(ids.iter().map(String::as_str));
|
||||
run(ep, &args, LIFECYCLE).map(drop)
|
||||
@@ -248,11 +232,6 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
|
||||
if ids.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
if docker_executable().is_none()
|
||||
&& let Some(ran) = engine::remove(ep, object, ids, force, LIFECYCLE)
|
||||
{
|
||||
return ran;
|
||||
}
|
||||
let mut args = vec![object.noun(), "rm"];
|
||||
if force && matches!(object, DockerObject::Container | DockerObject::Image | DockerObject::Volume) {
|
||||
args.push("--force");
|
||||
@@ -263,11 +242,6 @@ pub fn remove(ep: &DockerEndpoint, object: DockerObject, ids: &[String], force:
|
||||
|
||||
/// `docker inspect` of one object, pretty-printed.
|
||||
pub fn inspect(ep: &DockerEndpoint, object: DockerObject, id: &str) -> IdeResult<String> {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(inspected) = engine::inspect(ep, object, id, QUICK)
|
||||
{
|
||||
return inspected;
|
||||
}
|
||||
let out = run(ep, &["inspect", "--type", object.noun(), id], QUICK)?;
|
||||
match serde_json::from_str::<serde_json::Value>(&out) {
|
||||
// A one-element array for a single id: show the object itself.
|
||||
|
||||
@@ -211,10 +211,10 @@ pub fn parse_labels(raw: &str) -> BTreeMap<String, String> {
|
||||
out
|
||||
}
|
||||
|
||||
pub(crate) const COMPOSE_PROJECT: &str = "com.docker.compose.project";
|
||||
pub(crate) const COMPOSE_SERVICE: &str = "com.docker.compose.service";
|
||||
pub(crate) const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
|
||||
pub(crate) const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
|
||||
const COMPOSE_PROJECT: &str = "com.docker.compose.project";
|
||||
const COMPOSE_SERVICE: &str = "com.docker.compose.service";
|
||||
const COMPOSE_DIR: &str = "com.docker.compose.project.working_dir";
|
||||
const COMPOSE_FILES: &str = "com.docker.compose.project.config_files";
|
||||
|
||||
fn lines<T: for<'de> Deserialize<'de>>(text: &str) -> impl Iterator<Item = T> + '_ {
|
||||
text.lines().filter(|l| l.trim_start().starts_with('{')).filter_map(|l| match serde_json::from_str::<T>(l) {
|
||||
@@ -253,7 +253,7 @@ struct RawContainer {
|
||||
networks: String,
|
||||
}
|
||||
|
||||
pub(crate) fn split_csv(raw: &str) -> Vec<String> {
|
||||
fn split_csv(raw: &str) -> Vec<String> {
|
||||
raw.split(',').map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
|
||||
@@ -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.13.0";
|
||||
pub const ENGINE_VERSION: &str = "1.11.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.
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
[package]
|
||||
name = "ide-flutter"
|
||||
description = "Flutter devices, kept current by the `flutter daemon` protocol"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
ide-android = { path = "../ide-android" }
|
||||
ide-core.workspace = true
|
||||
parking_lot.workspace = true
|
||||
serde_json.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -1,563 +0,0 @@
|
||||
//! The devices a Flutter project can run on, from one `flutter daemon` per project window.
|
||||
//!
|
||||
//! The daemon speaks JSON-RPC over stdio, one bracketed message per line. After
|
||||
//! `daemon.connected` it is asked for `device.enable`, which makes it report `device.added` /
|
||||
//! `device.removed`, and once for `device.getDevices`, whose answer ends the "discovering" state.
|
||||
//!
|
||||
//! The daemon keeps running after its stdin closes, so closing the pipe does not end it: on Unix
|
||||
//! a watcher in its process group ends the group once the IDE is gone, even after a crash. A
|
||||
//! daemon that fails stays failed until the user restarts it.
|
||||
|
||||
use ide_android::AndroidDevice;
|
||||
use ide_core::event::{FlutterDaemonStatus, FlutterDevice, FlutterDeviceList};
|
||||
use ide_core::process::{kill_tree, own_group, prepare, terminate_tree};
|
||||
use ide_core::tool_path::{find_command, search_path_in};
|
||||
use ide_core::{IdeEvent, SharedSink};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::{BTreeMap, VecDeque};
|
||||
use std::io::{BufRead, BufReader, Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Child, ChildStdin, Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const ENABLE: u64 = 1;
|
||||
const GET_DEVICES: u64 = 2;
|
||||
/// How long the daemon gets to exit on `SIGTERM`.
|
||||
const KILL_GRACE: Duration = Duration::from_millis(200);
|
||||
/// Lines of unrecognised output kept to explain a failure.
|
||||
const OUTPUT_TAIL: usize = 8;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
enum Message {
|
||||
Connected,
|
||||
Added(FlutterDevice),
|
||||
Removed(String),
|
||||
Devices(Vec<FlutterDevice>),
|
||||
Other,
|
||||
}
|
||||
|
||||
fn device(value: &Value) -> Option<FlutterDevice> {
|
||||
let text = |key| value.get(key).and_then(Value::as_str).map(str::to_owned);
|
||||
Some(FlutterDevice {
|
||||
id: text("id")?,
|
||||
name: text("name")?,
|
||||
platform_type: text("platformType"),
|
||||
category: text("category"),
|
||||
emulator: value.get("emulator").and_then(Value::as_bool).unwrap_or(false),
|
||||
unavailable: None,
|
||||
})
|
||||
}
|
||||
|
||||
/// The messages of one stdout line; `None` for anything outside the protocol (the tool's own
|
||||
/// chatter, such as waiting for the startup lock).
|
||||
fn parse_line(line: &str) -> Option<Vec<Message>> {
|
||||
let line = line.trim();
|
||||
if !line.starts_with('[') {
|
||||
return None;
|
||||
}
|
||||
let messages: Vec<Value> = serde_json::from_str(line).ok()?;
|
||||
Some(messages.iter().map(parse_message).collect())
|
||||
}
|
||||
|
||||
fn parse_message(message: &Value) -> Message {
|
||||
let params = message.get("params").unwrap_or(&Value::Null);
|
||||
match message.get("event").and_then(Value::as_str) {
|
||||
Some("daemon.connected") => Message::Connected,
|
||||
Some("device.added") => device(params).map_or(Message::Other, Message::Added),
|
||||
Some("device.removed") => {
|
||||
params.get("id").and_then(Value::as_str).map_or(Message::Other, |id| Message::Removed(id.to_owned()))
|
||||
}
|
||||
Some(_) => Message::Other,
|
||||
None if message.get("id").and_then(Value::as_u64) == Some(GET_DEVICES) => {
|
||||
let result = message.get("result").and_then(Value::as_array);
|
||||
Message::Devices(result.into_iter().flatten().filter_map(device).collect())
|
||||
}
|
||||
None => Message::Other,
|
||||
}
|
||||
}
|
||||
|
||||
fn request(id: u64, method: &str) -> String {
|
||||
format!("{}\n", json!([{ "id": id, "method": method }]))
|
||||
}
|
||||
|
||||
/// The daemon's devices, plus the Android devices adb sees that Flutter leaves out until they
|
||||
/// are usable. A daemon Android device's id is its adb serial.
|
||||
fn merged(daemon: &BTreeMap<String, FlutterDevice>, adb: &[AndroidDevice]) -> Vec<FlutterDevice> {
|
||||
let mut devices: Vec<FlutterDevice> = daemon.values().cloned().collect();
|
||||
devices.extend(adb.iter().filter(|d| !d.is_online() && !daemon.contains_key(&d.serial)).map(|d| FlutterDevice {
|
||||
id: d.serial.clone(),
|
||||
name: d.label().replace('_', " "),
|
||||
platform_type: Some("android".into()),
|
||||
category: Some("mobile".into()),
|
||||
emulator: d.serial.starts_with("emulator-"),
|
||||
unavailable: Some(d.state.clone()),
|
||||
}));
|
||||
let rank = |d: &FlutterDevice| match d.category.as_deref() {
|
||||
Some("mobile") => 0,
|
||||
Some("desktop") => 1,
|
||||
Some("web") => 2,
|
||||
_ => 3,
|
||||
};
|
||||
devices.sort_by_cached_key(|d| (d.unavailable.is_some(), rank(d), d.emulator, d.name.to_lowercase(), d.id.clone()));
|
||||
devices
|
||||
}
|
||||
|
||||
struct Running {
|
||||
child: Child,
|
||||
stdin: Option<ChildStdin>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct State {
|
||||
/// Bumped by every start and stop: a reader of an older process no longer has a say.
|
||||
generation: u64,
|
||||
running: Option<Running>,
|
||||
status: FlutterDaemonStatus,
|
||||
devices: BTreeMap<String, FlutterDevice>,
|
||||
adb: Vec<AndroidDevice>,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn list(&self) -> FlutterDeviceList {
|
||||
FlutterDeviceList { status: self.status.clone(), devices: merged(&self.devices, &self.adb) }
|
||||
}
|
||||
|
||||
fn shut_down(&mut self) {
|
||||
self.generation += 1;
|
||||
if let Some(Running { mut child, stdin }) = self.running.take() {
|
||||
drop(stdin);
|
||||
// Off the caller's thread: closing a window must not wait for the grace period.
|
||||
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Shared {
|
||||
root: PathBuf,
|
||||
sink: SharedSink,
|
||||
/// Replaces the lookup on the search path (tests).
|
||||
executable: Option<PathBuf>,
|
||||
state: Mutex<State>,
|
||||
}
|
||||
|
||||
impl Shared {
|
||||
fn emit(&self, list: FlutterDeviceList) {
|
||||
self.sink.emit(IdeEvent::FlutterDevices { list });
|
||||
}
|
||||
}
|
||||
|
||||
/// One project window's `flutter daemon`, started on first use.
|
||||
pub struct FlutterDaemon(Arc<Shared>);
|
||||
|
||||
impl FlutterDaemon {
|
||||
pub fn new(root: PathBuf, sink: SharedSink) -> Self {
|
||||
Self::with_executable(root, sink, None)
|
||||
}
|
||||
|
||||
fn with_executable(root: PathBuf, sink: SharedSink, executable: Option<PathBuf>) -> Self {
|
||||
Self(Arc::new(Shared { root, sink, executable, state: Mutex::default() }))
|
||||
}
|
||||
|
||||
/// The current list; starts the daemon unless it already ran. Never blocks on the process.
|
||||
pub fn devices(&self) -> FlutterDeviceList {
|
||||
let mut state = self.0.state.lock();
|
||||
if state.status == FlutterDaemonStatus::Stopped {
|
||||
start(&self.0, &mut state);
|
||||
}
|
||||
state.list()
|
||||
}
|
||||
|
||||
/// Replaces the daemon with a new one (the user's way out of a failure).
|
||||
pub fn restart(&self) -> FlutterDeviceList {
|
||||
let mut state = self.0.state.lock();
|
||||
state.shut_down();
|
||||
start(&self.0, &mut state);
|
||||
state.list()
|
||||
}
|
||||
|
||||
/// Reads adb again: a device awaiting authorization changes no daemon event.
|
||||
pub fn refresh(&self) {
|
||||
let generation = self.0.state.lock().generation;
|
||||
refresh_adb(&self.0, generation);
|
||||
}
|
||||
|
||||
/// Ends the daemon (project closed, or no longer trusted).
|
||||
pub fn stop(&self) {
|
||||
let mut state = self.0.state.lock();
|
||||
state.shut_down();
|
||||
state.status = FlutterDaemonStatus::Stopped;
|
||||
state.devices.clear();
|
||||
state.adb.clear();
|
||||
}
|
||||
|
||||
/// Ends the daemon before returning, for a process about to exit.
|
||||
pub fn kill(&self) {
|
||||
let mut state = self.0.state.lock();
|
||||
state.generation += 1;
|
||||
if let Some(mut running) = state.running.take() {
|
||||
kill_tree(&mut running.child);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn start(shared: &Arc<Shared>, state: &mut State) {
|
||||
state.generation += 1;
|
||||
state.status = FlutterDaemonStatus::Starting;
|
||||
state.devices.clear();
|
||||
state.adb.clear();
|
||||
let (shared, generation) = (shared.clone(), state.generation);
|
||||
std::thread::spawn(move || run(&shared, generation));
|
||||
}
|
||||
|
||||
fn refresh_adb(shared: &Arc<Shared>, generation: u64) {
|
||||
let shared = shared.clone();
|
||||
std::thread::spawn(move || {
|
||||
// Without adb there is simply nothing to add.
|
||||
let adb = ide_android::devices().unwrap_or_default();
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation || state.adb == adb {
|
||||
return;
|
||||
}
|
||||
state.adb = adb;
|
||||
let list = state.list();
|
||||
drop(state);
|
||||
shared.emit(list);
|
||||
});
|
||||
}
|
||||
|
||||
/// `flutter daemon`, ended with its whole process group when process `parent` is gone.
|
||||
#[cfg(unix)]
|
||||
fn daemon_command(executable: &Path, parent: u32) -> Command {
|
||||
const WATCHED: &str = r#"(while kill -0 "$1" 2>/dev/null; do sleep 5; done; kill -KILL 0) </dev/null >/dev/null 2>&1 &
|
||||
exec "$2" daemon"#;
|
||||
let mut cmd = Command::new("/bin/sh");
|
||||
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable);
|
||||
cmd
|
||||
}
|
||||
|
||||
// No watcher on Windows, so a crashed IDE leaves the daemon; a Job Object would cover it.
|
||||
#[cfg(not(unix))]
|
||||
fn daemon_command(executable: &Path, _parent: u32) -> Command {
|
||||
let mut cmd = Command::new(executable);
|
||||
cmd.arg("daemon");
|
||||
cmd
|
||||
}
|
||||
|
||||
fn spawn_daemon(executable: &Path, root: &Path) -> std::io::Result<Child> {
|
||||
let mut cmd = daemon_command(executable, std::process::id());
|
||||
cmd.current_dir(root).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
prepare(own_group(&mut cmd));
|
||||
cmd.spawn()
|
||||
}
|
||||
|
||||
/// Sets the final status of a daemon that is gone, unless it was replaced or stopped meanwhile.
|
||||
fn finish(shared: &Shared, generation: u64, status: FlutterDaemonStatus) {
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation {
|
||||
return;
|
||||
}
|
||||
let running = state.running.take();
|
||||
state.status = status;
|
||||
let list = state.list();
|
||||
drop(state);
|
||||
if let Some(Running { mut child, .. }) = running {
|
||||
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
|
||||
}
|
||||
shared.emit(list);
|
||||
}
|
||||
|
||||
fn keep_output(tail: &Mutex<VecDeque<String>>, line: &str) {
|
||||
if line.trim().is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut tail = tail.lock();
|
||||
if tail.len() == OUTPUT_TAIL {
|
||||
tail.pop_front();
|
||||
}
|
||||
tail.push_back(line.trim_end().to_owned());
|
||||
}
|
||||
|
||||
fn read_lines(pipe: impl Read, mut on_line: impl FnMut(&str) -> bool) {
|
||||
let mut reader = BufReader::new(pipe);
|
||||
let mut bytes = Vec::new();
|
||||
loop {
|
||||
bytes.clear();
|
||||
match reader.read_until(b'\n', &mut bytes) {
|
||||
Ok(0) | Err(_) => return,
|
||||
Ok(_) if !on_line(&String::from_utf8_lossy(&bytes)) => return,
|
||||
Ok(_) => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One daemon's whole life, on its own thread.
|
||||
fn run(shared: &Arc<Shared>, generation: u64) {
|
||||
let executable =
|
||||
shared.executable.clone().or_else(|| find_command("flutter", &search_path_in(&shared.root), &shared.root));
|
||||
let Some(executable) = executable else {
|
||||
return finish(shared, generation, FlutterDaemonStatus::NotInstalled);
|
||||
};
|
||||
let mut child = match spawn_daemon(&executable, &shared.root) {
|
||||
Ok(child) => child,
|
||||
Err(e) => {
|
||||
let message = format!("could not run {}: {e}", executable.display());
|
||||
return finish(shared, generation, FlutterDaemonStatus::Failed { message });
|
||||
}
|
||||
};
|
||||
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
|
||||
return finish(shared, generation, FlutterDaemonStatus::Failed { message: "no output pipe".into() });
|
||||
};
|
||||
let stdin = child.stdin.take();
|
||||
{
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation {
|
||||
drop(state);
|
||||
drop(stdin);
|
||||
terminate_tree(&mut child, KILL_GRACE);
|
||||
return;
|
||||
}
|
||||
state.running = Some(Running { child, stdin });
|
||||
}
|
||||
let tail = Arc::new(Mutex::new(VecDeque::new()));
|
||||
let errors = {
|
||||
let tail = tail.clone();
|
||||
std::thread::spawn(move || {
|
||||
read_lines(stderr, |line| {
|
||||
keep_output(&tail, line);
|
||||
true
|
||||
});
|
||||
})
|
||||
};
|
||||
read_lines(stdout, |line| match parse_line(line) {
|
||||
Some(messages) => messages.into_iter().all(|message| handle(shared, generation, message)),
|
||||
None => {
|
||||
keep_output(&tail, line);
|
||||
true
|
||||
}
|
||||
});
|
||||
let _ = errors.join();
|
||||
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
|
||||
let message = if message.is_empty() { "flutter daemon exited".to_owned() } else { message };
|
||||
finish(shared, generation, FlutterDaemonStatus::Failed { message });
|
||||
}
|
||||
|
||||
/// Applies one message; false once this daemon has been replaced or stopped.
|
||||
fn handle(shared: &Arc<Shared>, generation: u64, message: Message) -> bool {
|
||||
let mut state = shared.state.lock();
|
||||
if state.generation != generation {
|
||||
return false;
|
||||
}
|
||||
match message {
|
||||
Message::Other => return true,
|
||||
Message::Connected => {
|
||||
if let Some(stdin) = state.running.as_mut().and_then(|r| r.stdin.as_mut()) {
|
||||
let requests = request(ENABLE, "device.enable") + &request(GET_DEVICES, "device.getDevices");
|
||||
let _ = stdin.write_all(requests.as_bytes()).and_then(|()| stdin.flush());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
Message::Added(device) => {
|
||||
state.devices.insert(device.id.clone(), device);
|
||||
}
|
||||
Message::Removed(id) => {
|
||||
state.devices.remove(&id);
|
||||
}
|
||||
// Merged, not replaced: events may have overtaken this answer.
|
||||
Message::Devices(devices) => {
|
||||
state.devices.extend(devices.into_iter().map(|d| (d.id.clone(), d)));
|
||||
state.status = FlutterDaemonStatus::Ready;
|
||||
}
|
||||
}
|
||||
let list = state.list();
|
||||
drop(state);
|
||||
shared.emit(list);
|
||||
refresh_adb(shared, generation);
|
||||
true
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn dev(id: &str, name: &str, category: &str, emulator: bool) -> FlutterDevice {
|
||||
FlutterDevice {
|
||||
id: id.into(),
|
||||
name: name.into(),
|
||||
platform_type: None,
|
||||
category: Some(category.into()),
|
||||
emulator,
|
||||
unavailable: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn adb(serial: &str, state: &str) -> AndroidDevice {
|
||||
AndroidDevice {
|
||||
serial: serial.into(),
|
||||
state: state.into(),
|
||||
model: None,
|
||||
product: None,
|
||||
device: None,
|
||||
transport_id: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_the_daemon_protocol() {
|
||||
assert_eq!(
|
||||
parse_line(r#"[{"event":"daemon.connected","params":{"version":"0.6.1","pid":7}}]"#),
|
||||
Some(vec![Message::Connected])
|
||||
);
|
||||
let added = parse_line(
|
||||
r#"[{"event":"device.added","params":{"id":"emulator-5554","name":"Pixel","platform":"android-arm64",
|
||||
"emulator":true,"category":"mobile","platformType":"android","ephemeral":true}}]"#
|
||||
.replace('\n', " ")
|
||||
.as_str(),
|
||||
);
|
||||
let Some([Message::Added(device)]) = added.as_deref() else { panic!("{added:?}") };
|
||||
assert_eq!(device.id, "emulator-5554");
|
||||
assert_eq!(device.platform_type.as_deref(), Some("android"));
|
||||
assert!(device.emulator);
|
||||
assert_eq!(
|
||||
parse_line(r#"[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]"#),
|
||||
Some(vec![Message::Removed("macos".into())])
|
||||
);
|
||||
let answer = parse_line(r#"[{"id":2,"result":[{"id":"chrome","name":"Chrome","category":null}]}]"#);
|
||||
let Some([Message::Devices(devices)]) = answer.as_deref() else { panic!("{answer:?}") };
|
||||
assert_eq!((devices[0].id.as_str(), devices[0].category.as_deref()), ("chrome", None));
|
||||
assert_eq!(parse_line(r#"[{"id":1,"result":null}]"#), Some(vec![Message::Other]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn output_outside_the_protocol_is_not_a_message() {
|
||||
assert_eq!(parse_line("Waiting for another flutter command to release the startup lock..."), None);
|
||||
assert_eq!(parse_line("[not json"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_usable_devices_first_and_adds_what_only_adb_sees() {
|
||||
let daemon: BTreeMap<_, _> = [
|
||||
dev("chrome", "Chrome", "web", false),
|
||||
dev("macos", "macOS", "desktop", false),
|
||||
dev("emulator-5554", "Pixel", "mobile", true),
|
||||
dev("R5C", "Galaxy", "mobile", false),
|
||||
]
|
||||
.into_iter()
|
||||
.map(|d| (d.id.clone(), d))
|
||||
.collect();
|
||||
let adb = [adb("R5C", "device"), adb("emulator-5554", "offline"), adb("X1", "unauthorized")];
|
||||
let list = merged(&daemon, &adb);
|
||||
let ids: Vec<_> = list.iter().map(|d| d.id.as_str()).collect();
|
||||
assert_eq!(ids, ["R5C", "emulator-5554", "macos", "chrome", "X1"]);
|
||||
assert_eq!(list[4].unavailable.as_deref(), Some("unauthorized"));
|
||||
assert_eq!(list[1].unavailable, None, "what the daemon lists is usable");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
mod process {
|
||||
use super::super::*;
|
||||
use ide_core::EventSink;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
use std::time::Instant;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Lists(Mutex<Vec<FlutterDeviceList>>);
|
||||
|
||||
impl EventSink for Lists {
|
||||
fn emit(&self, event: IdeEvent) {
|
||||
if let IdeEvent::FlutterDevices { list } = event {
|
||||
self.0.lock().push(list);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn daemon(dir: &Path, script: &str) -> (FlutterDaemon, Arc<Lists>) {
|
||||
let path = dir.join("flutter");
|
||||
std::fs::write(&path, format!("#!/bin/sh\n{script}")).unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let lists = Arc::new(Lists::default());
|
||||
(FlutterDaemon::with_executable(dir.to_owned(), lists.clone(), Some(path)), lists)
|
||||
}
|
||||
|
||||
fn wait_for(what: &str, done: impl Fn() -> bool) {
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
while !done() {
|
||||
assert!(Instant::now() < deadline, "timed out waiting for {what}");
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
const SESSION: &str = r#"
|
||||
echo $$ > pid
|
||||
echo 'Waiting for another flutter command to release the startup lock...'
|
||||
echo '[{"event":"daemon.connected","params":{"version":"0.6.1","pid":1}}]'
|
||||
read enable; read get; echo "$enable$get" > requests
|
||||
echo '[{"id":1,"result":null}]'
|
||||
echo '[{"id":2,"result":[{"id":"macos","name":"macOS","category":"desktop","emulator":false}]}]'
|
||||
echo '[{"event":"device.added","params":{"id":"chrome","name":"Chrome","category":"web","emulator":false}}]'
|
||||
echo '[{"event":"device.removed","params":{"id":"macos","name":"macOS"}}]'
|
||||
cat > /dev/null
|
||||
"#;
|
||||
|
||||
#[test]
|
||||
fn follows_devices_and_ends_with_the_project() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (daemon, lists) = daemon(dir.path(), SESSION);
|
||||
assert_eq!(daemon.devices().status, FlutterDaemonStatus::Starting);
|
||||
wait_for("the removal", || {
|
||||
let list = daemon.devices();
|
||||
list.status == FlutterDaemonStatus::Ready
|
||||
&& list.devices.iter().map(|d| d.id.as_str()).collect::<Vec<_>>() == ["chrome"]
|
||||
});
|
||||
let requests = std::fs::read_to_string(dir.path().join("requests")).unwrap();
|
||||
assert!(requests.contains("device.enable") && requests.contains("device.getDevices"), "{requests}");
|
||||
assert!(lists.0.lock().iter().any(|l| l.devices.iter().any(|d| d.id == "macos")));
|
||||
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
|
||||
let alive =
|
||||
|| Command::new("kill").args(["-0", pid.trim()]).stderr(Stdio::null()).status().unwrap().success();
|
||||
assert!(alive());
|
||||
daemon.stop();
|
||||
wait_for("the process to end", || !alive());
|
||||
assert_eq!(daemon.0.state.lock().status, FlutterDaemonStatus::Stopped);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_daemon_does_not_outlive_the_ide() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let flutter = dir.path().join("flutter");
|
||||
std::fs::write(&flutter, "#!/bin/sh\necho $$ > pid\nexec sleep 60\n").unwrap();
|
||||
std::fs::set_permissions(&flutter, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let mut ide = Command::new("sleep").arg("60").spawn().unwrap();
|
||||
let mut cmd = daemon_command(&flutter, ide.id());
|
||||
cmd.current_dir(dir.path()).stdin(Stdio::piped());
|
||||
let mut daemon = own_group(&mut cmd).spawn().unwrap();
|
||||
wait_for("the daemon", || dir.path().join("pid").is_file());
|
||||
assert_eq!(daemon.try_wait().unwrap(), None);
|
||||
ide.kill().unwrap();
|
||||
ide.wait().unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
while daemon.try_wait().unwrap().is_none() {
|
||||
assert!(Instant::now() < deadline, "the daemon outlived its parent");
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_crash_is_reported_and_not_restarted_until_asked() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (daemon, _lists) = daemon(dir.path(), "echo run >> runs\necho 'SDK is broken' >&2\nexit 3\n");
|
||||
daemon.devices();
|
||||
let failed = || matches!(daemon.0.state.lock().status, FlutterDaemonStatus::Failed { .. });
|
||||
wait_for("the failure", failed);
|
||||
let FlutterDaemonStatus::Failed { message } = daemon.devices().status else { panic!("still failed") };
|
||||
assert_eq!(message, "SDK is broken");
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
let runs = || std::fs::read_to_string(dir.path().join("runs")).unwrap().lines().count();
|
||||
assert_eq!(runs(), 1);
|
||||
daemon.restart();
|
||||
wait_for("the second run", || runs() == 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -58,7 +58,6 @@ ide-plugin.workspace = true
|
||||
ide-tools = { path = "../ide-tools" }
|
||||
ide-scaffold.workspace = true
|
||||
ide-docker = { path = "../ide-docker" }
|
||||
ide-flutter = { path = "../ide-flutter" }
|
||||
semver = "1"
|
||||
serde.workspace = true
|
||||
jsonschema = { version = "0.33", default-features = false }
|
||||
|
||||
@@ -11,12 +11,7 @@ use std::path::PathBuf;
|
||||
use std::sync::{Arc, OnceLock};
|
||||
|
||||
fn main() {
|
||||
let raw_args: Vec<String> = std::env::args().collect();
|
||||
if let Some(project) = ide_mcp::stdio_request(&raw_args) {
|
||||
let base = server_home();
|
||||
std::process::exit(ide_mcp::stdio::run(&ide_mcp::discovery_path(&base.join("data")), project));
|
||||
}
|
||||
let args: Vec<String> = raw_args.into_iter().skip(1).collect();
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
if args.iter().any(|a| a == "--version") {
|
||||
println!("openidea-server {} (protocol {})", env!("CARGO_PKG_VERSION"), rpc::PROTOCOL_VERSION);
|
||||
return;
|
||||
@@ -36,9 +31,7 @@ fn main() {
|
||||
std::process::exit(code);
|
||||
}
|
||||
if !args.iter().any(|a| a == "--stdio") {
|
||||
eprintln!(
|
||||
"usage: openidea-server --stdio | --mcp-stdio [--project <path>] | --connect <host> <port> | --version"
|
||||
);
|
||||
eprintln!("usage: openidea-server --stdio | --connect <host> <port> | --version");
|
||||
std::process::exit(2);
|
||||
}
|
||||
// stdout carries the protocol: logs go to stderr.
|
||||
@@ -46,7 +39,8 @@ fn main() {
|
||||
.with_writer(std::io::stderr)
|
||||
.with_env_filter(tracing_subscriber::EnvFilter::try_from_env("OPENIDEA_LOG").unwrap_or_else(|_| "info".into()))
|
||||
.init();
|
||||
let base = server_home();
|
||||
let home = dirs::home_dir().unwrap_or_default();
|
||||
let base = std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"));
|
||||
// An SSH exec channel gets a minimal environment: take the login shell's, read
|
||||
// afresh on every start, plus the IDE-managed tools. Before any other thread starts.
|
||||
ide_host::shell_env::inherit_login_shell_env("openidea-server");
|
||||
@@ -59,11 +53,6 @@ fn main() {
|
||||
std::process::exit(code);
|
||||
}
|
||||
|
||||
fn server_home() -> PathBuf {
|
||||
let home = dirs::home_dir().unwrap_or_default();
|
||||
std::env::var_os("OPENIDEA_SERVER_HOME").map(PathBuf::from).unwrap_or_else(|| home.join(".openidea"))
|
||||
}
|
||||
|
||||
async fn run(base: PathBuf) -> i32 {
|
||||
let (config_dir, data_dir) = (base.join("config"), base.join("data"));
|
||||
for dir in [&config_dir, &data_dir] {
|
||||
@@ -96,9 +85,6 @@ async fn run(base: PathBuf) -> i32 {
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: true,
|
||||
}));
|
||||
// A stable path for `--mcp-stdio` client configurations across server upgrades.
|
||||
host.mcp.set_stdio_link(base.join("bin").join("openidea-server"));
|
||||
host.mcp.apply(&host);
|
||||
// The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
|
||||
let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
|
||||
Ok(p) => Some(p),
|
||||
@@ -126,7 +112,6 @@ async fn run(base: PathBuf) -> i32 {
|
||||
}
|
||||
});
|
||||
rpc::serve(host.clone(), dispatcher, peer, tokio::io::stdin(), tokio::io::stdout()).await;
|
||||
host.mcp.stop(&host);
|
||||
if let Some(plugins) = &plugins {
|
||||
plugins.host().shutdown();
|
||||
}
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
use crate::Host;
|
||||
use ide_core::event::NotifyLevel;
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings, Settings};
|
||||
use ide_core::{ChangeSet, DocId, IdeError, IdeEvent, IdeResult, LanguageId, Pos, Range, TextEdit};
|
||||
use ide_language::{LanguageConfig, PhpAlignment, Syntax};
|
||||
use ide_core::settings::{ExternalFormatter, LanguagesSettings};
|
||||
use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Pos, Range, TextEdit};
|
||||
use ide_language::LanguageConfig;
|
||||
use ide_lsp::types::FormatOptions;
|
||||
use ide_tools::{Tools, formatter};
|
||||
use std::path::Path;
|
||||
@@ -129,101 +129,12 @@ pub async fn format(
|
||||
let project = host.project(window)?;
|
||||
let snap = project.documents.snapshot(doc)?;
|
||||
let settings = project.settings.effective();
|
||||
let alignment = php_alignment(&settings, &snap.language);
|
||||
let original = alignment.any().then(|| (snap.language.clone(), snap.text.clone()));
|
||||
let Some(edits) = provider_edits(host, window, &project, snap, settings, range, options).await? else {
|
||||
return Ok(Vec::new());
|
||||
};
|
||||
let Some((language, text)) = original else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let syntax = host.syntax();
|
||||
tokio::task::spawn_blocking(move || align_formatted(&syntax, &language, &text, edits, range, alignment))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// PHP Code Style › Align key-value pairs / Align consecutive assignments (off by default, as in PhpStorm).
|
||||
fn php_alignment(settings: &Settings, language: &LanguageId) -> PhpAlignment {
|
||||
let style = settings.editor.code_style.languages.get(language.as_str());
|
||||
PhpAlignment {
|
||||
key_value_pairs: style.and_then(|s| s.align_key_value_pairs).unwrap_or(false),
|
||||
assignments: style.and_then(|s| s.align_consecutive_assignments).unwrap_or(false),
|
||||
}
|
||||
}
|
||||
|
||||
/// The formatter's `edits` to `text` followed by the alignment, as one set of edits to `text`.
|
||||
/// With a `range`, only its lines (where the formatter left them) are aligned.
|
||||
fn align_formatted(
|
||||
syntax: &Syntax,
|
||||
language: &LanguageId,
|
||||
text: &str,
|
||||
edits: Vec<TextEdit>,
|
||||
range: Option<Range>,
|
||||
alignment: PhpAlignment,
|
||||
) -> IdeResult<Vec<TextEdit>> {
|
||||
let mut formatted = ide_text::Document::new(text);
|
||||
// Edits the editor has to sort out itself (overlapping ones) are passed on unaligned.
|
||||
let Ok((changes, _)) = formatted.apply_edits(&edits) else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let lines = range.map(|range| {
|
||||
let original = ide_text::Document::new(text);
|
||||
let start = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.start), false));
|
||||
let end = formatted.offset_to_pos(map_offset(&changes, original.pos_to_offset(range.end), true));
|
||||
let last = if end.col == 0 && end.line > start.line { end.line - 1 } else { end.line };
|
||||
(start.line as usize, last as usize)
|
||||
});
|
||||
let Some(aligned) = syntax.align_php(language, &formatted.text(), lines, alignment) else {
|
||||
return Ok(edits);
|
||||
};
|
||||
let original = ide_text::Document::new(text);
|
||||
Ok(original
|
||||
.diff(&aligned)
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Where UTF-16 `offset` of the text before `changes` ends up after them; inside a replaced
|
||||
/// part, at its start or (`end`) its end.
|
||||
fn map_offset(changes: &ChangeSet, offset: u32, end: bool) -> u32 {
|
||||
let mut shift: i64 = 0;
|
||||
for c in &changes.changes {
|
||||
let inserted = c.insert.encode_utf16().count() as i64;
|
||||
if c.to < offset || (c.to == offset && (c.from < c.to || end)) {
|
||||
shift += inserted - i64::from(c.to - c.from);
|
||||
} else if c.from < offset {
|
||||
return (i64::from(c.from) + shift + if end { inserted } else { 0 }) as u32;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
(i64::from(offset) + shift) as u32
|
||||
}
|
||||
|
||||
/// The edits of the formatter that handles the document; `None` when it doesn't run
|
||||
/// (formatting on save is off for it).
|
||||
async fn provider_edits(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
project: &crate::Project,
|
||||
snap: ide_workspace::documents::DocumentInfo,
|
||||
settings: Settings,
|
||||
range: Option<Range>,
|
||||
options: FormatOptions,
|
||||
) -> IdeResult<Option<Vec<TextEdit>>> {
|
||||
let doc = snap.id;
|
||||
let language = project.languages.get(&snap.language);
|
||||
if options.tool.is_none()
|
||||
&& let Some(id) = settings.languages.plugin_formatters.get(snap.language.as_str()).filter(|s| !s.is_empty())
|
||||
{
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
if snap.read_only {
|
||||
return Err(IdeError::invalid("The file is read-only"));
|
||||
@@ -249,8 +160,7 @@ async fn provider_edits(
|
||||
)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.map(Some);
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
}
|
||||
// A committed PHP-CS-Fixer configuration takes over Reformat Code for `.php` files.
|
||||
if options.tool.is_none()
|
||||
@@ -258,7 +168,7 @@ async fn provider_edits(
|
||||
&& let Some(fixer) = formatter::php_cs_fixer(&snap.path)
|
||||
{
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -278,7 +188,7 @@ async fn provider_edits(
|
||||
body: Some("PHP-CS-Fixer does not support selection formatting; formatted the whole file".into()),
|
||||
});
|
||||
}
|
||||
return Ok(Some(edits));
|
||||
return Ok(edits);
|
||||
}
|
||||
let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
|
||||
if let Some(tool) = selected
|
||||
@@ -290,13 +200,13 @@ async fn provider_edits(
|
||||
}
|
||||
let Some(selected) = selected else {
|
||||
if options.on_save && !settings.editor.format_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
return project.lsp.format(doc, range, options).await.map(Some);
|
||||
return project.lsp.format(doc, range, options).await;
|
||||
};
|
||||
let tool_settings = settings.languages.formatter(selected);
|
||||
if options.on_save && !tool_settings.run_on_save {
|
||||
return Ok(None);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
host.require_trust(window)?;
|
||||
if snap.read_only {
|
||||
@@ -352,7 +262,7 @@ async fn provider_edits(
|
||||
)),
|
||||
});
|
||||
}
|
||||
edits.map(Some).map_err(|e| e.with_tool(tool))
|
||||
edits.map_err(|e| e.with_tool(tool))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -503,103 +413,6 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
fn after(text: &str, edits: &[TextEdit]) -> String {
|
||||
let mut doc = ide_text::Document::new(text);
|
||||
doc.apply_edits(edits).unwrap();
|
||||
doc.text()
|
||||
}
|
||||
|
||||
fn whole_file(text: &str, formatted: &str) -> Vec<TextEdit> {
|
||||
let doc = ide_text::Document::new(text);
|
||||
doc.diff(formatted)
|
||||
.changes
|
||||
.into_iter()
|
||||
.map(|c| TextEdit {
|
||||
range: Range::new(doc.offset_to_pos(c.from), doc.offset_to_pos(c.to)),
|
||||
new_text: c.insert,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
|
||||
|
||||
#[test]
|
||||
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
|
||||
let php = LanguageId::new("php");
|
||||
let mut settings = Settings::default();
|
||||
assert_eq!(php_alignment(&settings, &php), PhpAlignment::default());
|
||||
let style =
|
||||
ide_core::editor_settings::LanguageCodeStyle { align_key_value_pairs: Some(true), ..Default::default() };
|
||||
settings.editor.code_style.languages.insert("php".into(), style);
|
||||
assert_eq!(php_alignment(&settings, &php), PhpAlignment { key_value_pairs: true, assignments: false });
|
||||
assert_eq!(php_alignment(&settings, &LanguageId::new("javascript")), PhpAlignment::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alignment_follows_the_formatter_edits_even_when_there_are_none() {
|
||||
let syntax = Syntax::new();
|
||||
let php = LanguageId::new("php");
|
||||
let text = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
let edits = align_formatted(&syntax, &php, text, Vec::new(), None, ALIGN).unwrap();
|
||||
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
|
||||
// The language server re-indents the array: the alignment applies to its result.
|
||||
let text = "<?php\n$a = [\n'a' => 1,\n'bbb' => 2,\n];\n";
|
||||
let formatted = "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
let edits = align_formatted(&syntax, &php, text, whole_file(text, formatted), None, ALIGN).unwrap();
|
||||
assert_eq!(after(text, &edits), "<?php\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
|
||||
let unchanged = whole_file(text, formatted);
|
||||
let off = align_formatted(&syntax, &php, text, unchanged.clone(), None, PhpAlignment::default()).unwrap();
|
||||
assert_eq!(off, unchanged);
|
||||
|
||||
let overlapping = vec![
|
||||
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 4)), new_text: "x".into() },
|
||||
TextEdit { range: Range::new(Pos::new(1, 2), Pos::new(1, 6)), new_text: "y".into() },
|
||||
];
|
||||
let passed = align_formatted(&syntax, &php, text, overlapping.clone(), None, ALIGN).unwrap();
|
||||
assert_eq!(passed, overlapping);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_selection_aligns_only_its_lines_whatever_the_formatter_changed() {
|
||||
let syntax = Syntax::new();
|
||||
let php = LanguageId::new("php");
|
||||
let text = "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n";
|
||||
// PHP-CS-Fixer formats the whole file (here: adds a line at the top) whatever the selection.
|
||||
let formatted = format!("<?php\n\ndeclare(strict_types=1);\n{}", &text["<?php\n".len()..]);
|
||||
let edits = whole_file(text, &formatted);
|
||||
// Lines 3..=6 select the array, up to the start of the line after it.
|
||||
let range = Range::new(Pos::new(3, 0), Pos::new(7, 0));
|
||||
let aligned = align_formatted(&syntax, &php, text, edits, Some(range), ALIGN).unwrap();
|
||||
assert_eq!(aligned.len(), 2, "one edit per changed region: {aligned:?}");
|
||||
assert_eq!(
|
||||
after(text, &aligned),
|
||||
"<?php\n\ndeclare(strict_types=1);\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n"
|
||||
);
|
||||
let range = Range::new(Pos::new(1, 0), Pos::new(2, 9));
|
||||
let aligned = align_formatted(&syntax, &php, text, Vec::new(), Some(range), ALIGN).unwrap();
|
||||
assert_eq!(after(text, &aligned), "<?php\n$x = 1;\n$yyy = 2;\n$a = [\n 'a' => 1,\n 'bbb' => 2,\n];\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn offsets_map_through_changes() {
|
||||
let changes = ChangeSet {
|
||||
changes: vec![
|
||||
ide_core::TextChange { from: 2, to: 2, insert: "ab".into() },
|
||||
ide_core::TextChange { from: 5, to: 8, insert: "x".into() },
|
||||
],
|
||||
};
|
||||
assert_eq!(map_offset(&changes, 0, false), 0);
|
||||
assert_eq!(map_offset(&changes, 2, false), 2);
|
||||
assert_eq!(map_offset(&changes, 2, true), 4);
|
||||
assert_eq!(map_offset(&changes, 4, false), 6);
|
||||
assert_eq!(map_offset(&changes, 6, false), 7);
|
||||
assert_eq!(map_offset(&changes, 6, true), 8);
|
||||
assert_eq!(map_offset(&changes, 8, false), 8);
|
||||
assert_eq!(map_offset(&changes, 10, false), 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ruff_ranges_are_one_based_unicode_columns() {
|
||||
let text = ide_text::Document::new("😀x = 1\ny = 2\n");
|
||||
|
||||
@@ -59,8 +59,7 @@ pub struct HostConfig {
|
||||
}
|
||||
|
||||
pub struct Host {
|
||||
pub(crate) mcp_executable: Arc<RwLock<Option<PathBuf>>>,
|
||||
pub mcp: mcp::McpService,
|
||||
pub(crate) mcp_executable: RwLock<Option<PathBuf>>,
|
||||
plugin_host: RwLock<std::sync::Weak<plugins::PluginHost>>,
|
||||
/// Every `Diagnostics` event the host ever emitted, per file and producer:
|
||||
/// the snapshot plugins read (`problems`), independent of windows and reports.
|
||||
@@ -153,8 +152,7 @@ impl Host {
|
||||
ssh.set_configs(global_settings.effective().ssh.configs);
|
||||
let host = Self {
|
||||
plugin_host: RwLock::default(),
|
||||
mcp_executable: Arc::default(),
|
||||
mcp: Default::default(),
|
||||
mcp_executable: RwLock::default(),
|
||||
diagnostics,
|
||||
mcp_reports: Default::default(),
|
||||
mcp_requests: Default::default(),
|
||||
@@ -224,12 +222,12 @@ impl Host {
|
||||
}
|
||||
}
|
||||
|
||||
/// Publishes the executable of the running built-in MCP service (`None` while it is off).
|
||||
/// Associates the plugin runtime that executes this host's project operations.
|
||||
/// Publishes only the executable of the running built-in MCP service.
|
||||
pub fn set_mcp_executable(&self, executable: Option<PathBuf>) {
|
||||
*self.mcp_executable.write() = executable;
|
||||
}
|
||||
|
||||
/// Associates the plugin runtime that executes this host's project operations.
|
||||
pub fn set_plugin_host(&self, plugins: &Arc<plugins::PluginHost>) {
|
||||
*self.plugin_host.write() = Arc::downgrade(plugins);
|
||||
}
|
||||
@@ -255,16 +253,6 @@ impl Host {
|
||||
self.project(window)?.require_trust()
|
||||
}
|
||||
|
||||
/// [`Self::require_trust`] for IDE-wide toolchain work (SDK detection, tool installs) that
|
||||
/// also runs from a window without a project, such as Settings opened from the Welcome
|
||||
/// screen: there is no project there to trust.
|
||||
pub fn require_trust_if_project(&self, window: &str) -> IdeResult<()> {
|
||||
match self.project(window) {
|
||||
Ok(project) => project.require_trust(),
|
||||
Err(_) => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
/// The window that owns what `window` starts.
|
||||
pub fn owner_window<'a>(&self, window: &'a str) -> &'a str {
|
||||
(self.owner)(window)
|
||||
@@ -343,7 +331,6 @@ impl Host {
|
||||
}
|
||||
project.documents.clear_workspace_edit_history();
|
||||
project.agents.shutdown();
|
||||
project.flutter.stop();
|
||||
project.notebooks.stop_admission();
|
||||
// What the closing window started goes with it — the builds and searches it
|
||||
// asked for, its runs, its shells and its debug sessions — and its language
|
||||
@@ -462,9 +449,6 @@ impl Host {
|
||||
pub fn stop_processes_on_exit(&self) {
|
||||
self.processes.kill_all();
|
||||
self.terminals.kill_all();
|
||||
for project in self.projects() {
|
||||
project.flutter.kill();
|
||||
}
|
||||
}
|
||||
|
||||
/// Called before desktop exit, which may bypass document destructors.
|
||||
@@ -486,7 +470,6 @@ impl Host {
|
||||
let projects: Vec<_> = self.projects.write().drain().map(|(_, p)| p).collect();
|
||||
for project in &projects {
|
||||
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
|
||||
project.flutter.kill();
|
||||
}
|
||||
for project in &projects {
|
||||
project.plugin_diagnostics.close();
|
||||
|
||||
@@ -869,7 +869,6 @@ async fn occurrences(
|
||||
scope,
|
||||
max_matches: 0,
|
||||
context,
|
||||
include_excluded: false,
|
||||
};
|
||||
let host = call.host();
|
||||
let request = crate::mcp::tool::request_id();
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use super::page::{OFFSET, Page};
|
||||
use super::search::{PathScope, paths_param};
|
||||
use super::scope::{self, Scope};
|
||||
use super::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{Diagnostic, IdeResult, Severity};
|
||||
use serde_json::{Map, Value, json};
|
||||
@@ -16,7 +16,7 @@ pub fn tools() -> Vec<Tool> {
|
||||
Use this tool to explore current open editors.",
|
||||
open_editors,
|
||||
)
|
||||
.param(paths_param()),
|
||||
.param(scope::param()),
|
||||
Tool::new(
|
||||
"get_current_file",
|
||||
"Returns the focused editor's file and selection reported by the IDE.
|
||||
@@ -45,20 +45,20 @@ Lines and UTF-16 columns are 1-based.",
|
||||
project_problems,
|
||||
)
|
||||
.param(Param::optional("errorsOnly", ParamType::Boolean, "Only errors (default) or warnings too"))
|
||||
.param(paths_param())
|
||||
.param(scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Problems to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET)),
|
||||
]
|
||||
}
|
||||
|
||||
async fn open_editors(call: Call) -> IdeResult<Output> {
|
||||
let paths = PathScope::of(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let windows = call.host.mcp_windows(call.root());
|
||||
let open = call.host.mcp_reports.editors(&windows);
|
||||
let active = call.host.mcp_reports.focused(call.window()).filter(|e| paths.matches_path(&e.path.0));
|
||||
let active = call.host.mcp_reports.focused(call.window()).filter(|e| dir.contains(&e.path.0));
|
||||
Output::json(json!({
|
||||
"activeFilePath": active.map(|e| call.display(&e.path.0)),
|
||||
"openFiles": open.iter().filter(|p| paths.matches_path(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
"openFiles": open.iter().filter(|p| dir.contains(p)).map(|p| call.display(p)).collect::<Vec<_>>(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -103,11 +103,11 @@ async fn file_problems(call: Call) -> IdeResult<Output> {
|
||||
async fn project_problems(call: Call) -> IdeResult<Output> {
|
||||
let page = Page::of(&call, PROBLEMS_LIMIT)?;
|
||||
let errors_only = call.flag("errorsOnly", true)?;
|
||||
let paths = PathScope::of(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let files = call.host.mcp_reports.problems(&call.host.mcp_windows(call.root()));
|
||||
let problems: Vec<(String, Value)> = files
|
||||
.into_iter()
|
||||
.filter(|f| paths.matches_path(&f.path.0))
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.flat_map(|f| {
|
||||
let path = call.display(&f.path.0);
|
||||
let wanted = f.items.into_iter().filter(|d| !errors_only || d.severity == Severity::Error);
|
||||
|
||||
@@ -8,10 +8,9 @@ use crate::mcp::util::{
|
||||
self, RELATIVE_PATH_IN_PROJECT_DESCRIPTION, TIMED_OUT_DESCRIPTION, TIMEOUT_MILLISECONDS_DESCRIPTION,
|
||||
};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_search::FileMask;
|
||||
use serde::Serialize;
|
||||
use serde_json::json;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::Path;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const DEFAULT_READ_LIMIT: i64 = 2000;
|
||||
@@ -167,9 +166,7 @@ fn list_directory_tree() -> Tool {
|
||||
"Provides a tree representation of the specified directory in the pseudo graphic format like `tree` utility does.
|
||||
Use this tool to explore the contents of a directory or the whole project.
|
||||
You MUST prefer this tool over listing directories via command line utilities like `ls` or `dir`.
|
||||
A page that starts inside a directory repeats the lines of the directories above it.
|
||||
What `.gitignore` ignores is marked [git-ignored] and what the project excludes [ide-excluded]; entries inside a
|
||||
marked directory are not marked again.",
|
||||
A page that starts inside a directory repeats the lines of the directories above it.",
|
||||
|call| async move {
|
||||
let directory = call.str("directoryPath")?;
|
||||
let max_depth = call.opt_i64("maxDepth")?.unwrap_or(DEFAULT_TREE_DEPTH);
|
||||
@@ -184,12 +181,6 @@ marked directory are not marked again.",
|
||||
}
|
||||
let deadline = Instant::now() + Duration::from_millis(timeout.max(0) as u64);
|
||||
let cancel = call.cancel.clone();
|
||||
let marks = Marks {
|
||||
root: call.root().to_path_buf(),
|
||||
excludes: FileMask::new(&[], &call.project().search_excludes()).ok(),
|
||||
};
|
||||
// The directory itself, when it or one above it is left out.
|
||||
let root_mark = marker(ide_index::walk_skips(call.root(), &dir), marks.ide_excluded(&dir, true));
|
||||
let mut tree = TreeRender {
|
||||
out: String::new(),
|
||||
errors: Vec::new(),
|
||||
@@ -199,12 +190,11 @@ marked directory are not marked again.",
|
||||
page,
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks,
|
||||
};
|
||||
let tree = call
|
||||
.host()
|
||||
.blocking(move || {
|
||||
tree.render(&dir, "", true, max_depth, true, root_mark, !root_mark.is_empty());
|
||||
tree.render(&dir, "", true, max_depth, true);
|
||||
Ok(tree)
|
||||
})
|
||||
.await?;
|
||||
@@ -244,8 +234,7 @@ marked directory are not marked again.",
|
||||
|
||||
/// The `tree`-like listing: the directory's absolute path, then every entry (hidden and
|
||||
/// ignored ones too) by lower-cased name, directories marked with `/`; entries outside the
|
||||
/// page are counted, not listed. An entry left out of the project is marked, the entries
|
||||
/// inside it are not.
|
||||
/// page are counted, not listed.
|
||||
struct TreeRender {
|
||||
out: String,
|
||||
errors: Vec<String>,
|
||||
@@ -257,48 +246,10 @@ struct TreeRender {
|
||||
seen: usize,
|
||||
/// The lines of the directories above the entry, and whether this page shows them yet.
|
||||
above: Vec<(String, bool)>,
|
||||
marks: Marks,
|
||||
}
|
||||
|
||||
/// What the project leaves out, to mark in the listing.
|
||||
struct Marks {
|
||||
root: PathBuf,
|
||||
/// The project's exclusions (excluded folders, "Exclude files" names), as Find in Files applies them.
|
||||
excludes: Option<FileMask>,
|
||||
}
|
||||
|
||||
impl Marks {
|
||||
fn ide_excluded(&self, path: &Path, is_dir: bool) -> bool {
|
||||
let (Some(mask), Ok(rel)) = (&self.excludes, path.strip_prefix(&self.root)) else { return false };
|
||||
let rel = rel.to_string_lossy().replace('\\', "/");
|
||||
// A directory is excluded with the files in it.
|
||||
!rel.is_empty() && !mask.matches(&if is_dir { format!("{rel}/x") } else { rel })
|
||||
}
|
||||
}
|
||||
|
||||
/// Spelled out, so that the listing says what it means.
|
||||
fn marker(git_ignored: bool, ide_excluded: bool) -> &'static str {
|
||||
match (git_ignored, ide_excluded) {
|
||||
(true, true) => " [git-ignored] [ide-excluded]",
|
||||
(true, false) => " [git-ignored]",
|
||||
(false, true) => " [ide-excluded]",
|
||||
(false, false) => "",
|
||||
}
|
||||
}
|
||||
|
||||
impl TreeRender {
|
||||
/// `mark`: the entry's marker; `marked`: it or a directory above it is marked.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn render(
|
||||
&mut self,
|
||||
path: &Path,
|
||||
indent: &str,
|
||||
is_last: bool,
|
||||
max_depth: i64,
|
||||
is_root: bool,
|
||||
mark: &str,
|
||||
marked: bool,
|
||||
) {
|
||||
fn render(&mut self, path: &Path, indent: &str, is_last: bool, max_depth: i64, is_root: bool) {
|
||||
if max_depth <= 0 || self.timed_out || self.cancel.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
@@ -317,7 +268,7 @@ impl TreeRender {
|
||||
path.file_name().unwrap_or_default().to_string_lossy().into_owned()
|
||||
};
|
||||
let is_dir = path.is_dir() && !path.is_symlink();
|
||||
let line = format!("{indent}{prefix}{name}{}{mark}\n", if is_dir { "/" } else { "" });
|
||||
let line = format!("{indent}{prefix}{name}{}\n", if is_dir { "/" } else { "" });
|
||||
let shown = if is_root {
|
||||
self.out.push_str(&line);
|
||||
true
|
||||
@@ -327,38 +278,22 @@ impl TreeRender {
|
||||
if !is_dir {
|
||||
return;
|
||||
}
|
||||
// Without exclusions, `ignored` is what `.gitignore` says.
|
||||
let mut children: Vec<(PathBuf, bool)> = match ide_vfs::read_dir(path, &[]) {
|
||||
Ok(entries) => entries.into_iter().map(|e| (e.path.0, e.ignored)).collect(),
|
||||
let mut children: Vec<_> = match std::fs::read_dir(path) {
|
||||
Ok(entries) => entries.filter_map(|e| e.ok().map(|e| e.path())).collect(),
|
||||
Err(e) => {
|
||||
self.errors.push(format!("Failed to read {}: {}", path.display(), e.message));
|
||||
self.errors.push(format!("Failed to read {}: {e}", path.display()));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let key = |p: &PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
children.sort_by_cached_key(|(p, _)| (key(p).to_lowercase(), key(p)));
|
||||
let key = |p: &std::path::PathBuf| p.file_name().unwrap_or_default().to_string_lossy().into_owned();
|
||||
children.sort_by_cached_key(|p| (key(p).to_lowercase(), key(p)));
|
||||
let child_indent = format!("{indent}{}", if is_last { " " } else { "│ " });
|
||||
let n = children.len();
|
||||
if !is_root {
|
||||
self.above.push((line, shown));
|
||||
}
|
||||
// Inside a marked directory nothing is marked again.
|
||||
for (i, (child, git_ignored)) in children.iter().enumerate() {
|
||||
let child_mark = if marked {
|
||||
""
|
||||
} else {
|
||||
let child_dir = child.is_dir() && !child.is_symlink();
|
||||
marker(*git_ignored, self.marks.ide_excluded(child, child_dir))
|
||||
};
|
||||
self.render(
|
||||
child,
|
||||
&child_indent,
|
||||
i + 1 == n,
|
||||
max_depth - 1,
|
||||
false,
|
||||
child_mark,
|
||||
marked || !child_mark.is_empty(),
|
||||
);
|
||||
for (i, child) in children.iter().enumerate() {
|
||||
self.render(child, &child_indent, i + 1 == n, max_depth - 1, false);
|
||||
}
|
||||
if !is_root {
|
||||
self.above.pop();
|
||||
@@ -448,9 +383,8 @@ mod tests {
|
||||
page: Page { offset, limit },
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks: Marks { root: tmp.path().to_path_buf(), excludes: None },
|
||||
};
|
||||
tree.render(tmp.path(), "", true, 5, true, "", false);
|
||||
tree.render(tmp.path(), "", true, 5, true);
|
||||
let root = format!("{}/\n", tmp.path().display());
|
||||
(tree.out.strip_prefix(&root).unwrap().to_owned(), tree.seen)
|
||||
};
|
||||
@@ -462,48 +396,4 @@ mod tests {
|
||||
);
|
||||
assert_eq!(render(0, 100).0, " ├── a/\n │ ├── x.txt\n │ └── y.txt\n └── b.txt\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn what_the_project_leaves_out_is_marked_once() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap();
|
||||
for file in ["ign/deep/a.txt", "out/b.txt", "both/c.txt", "src/d.txt", "src/e.log"] {
|
||||
let path = root.join(file);
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(path, "").unwrap();
|
||||
}
|
||||
std::fs::write(root.join(".gitignore"), "ign/\nboth/\n*.log\n").unwrap();
|
||||
let excludes = ["out/**".to_owned(), "both/**".to_owned()];
|
||||
let mut tree = TreeRender {
|
||||
out: String::new(),
|
||||
errors: Vec::new(),
|
||||
timed_out: false,
|
||||
deadline: Instant::now() + Duration::from_secs(10),
|
||||
cancel: CancellationToken::new(),
|
||||
page: Page { offset: 0, limit: 100 },
|
||||
seen: 0,
|
||||
above: Vec::new(),
|
||||
marks: Marks { root: root.clone(), excludes: FileMask::new(&[], &excludes).ok() },
|
||||
};
|
||||
tree.render(&root, "", true, 5, true, "", false);
|
||||
let listing = tree.out.strip_prefix(&format!("{}/\n", root.display())).unwrap().to_owned();
|
||||
assert_eq!(
|
||||
listing,
|
||||
[
|
||||
" ├── .gitignore",
|
||||
" ├── both/ [git-ignored] [ide-excluded]",
|
||||
" │ └── c.txt",
|
||||
" ├── ign/ [git-ignored]",
|
||||
" │ └── deep/",
|
||||
" │ └── a.txt",
|
||||
" ├── out/ [ide-excluded]",
|
||||
" │ └── b.txt",
|
||||
" └── src/",
|
||||
" ├── d.txt",
|
||||
" └── e.log [git-ignored]",
|
||||
"",
|
||||
]
|
||||
.join("\n")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -10,8 +10,8 @@ mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
pub mod reports;
|
||||
mod scope;
|
||||
mod search;
|
||||
pub mod service;
|
||||
mod symbols;
|
||||
mod tool;
|
||||
mod util;
|
||||
@@ -23,7 +23,6 @@ pub use reports::{
|
||||
FileProblems, FocusedEditor, Reports, mcp_report_problems, mcp_set_focused_editor, mcp_set_open_editors,
|
||||
};
|
||||
pub use run::agent::{AGENT_PARAM, AgentRun, AgentRuns, NAME_PREFIX, SHELL_PARAM};
|
||||
pub use service::{McpServerStatus, McpService};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -57,7 +56,7 @@ fn allowed(tool: &ide_mcp::Tool, trusted: bool) -> bool {
|
||||
impl Registry {
|
||||
fn target(&self, root: &Path) -> Result<(String, Arc<crate::Project>), String> {
|
||||
if self.0.mcp_reports.remote_roots().iter().any(|p| p == root) {
|
||||
return Err("project is on a remote host; connect to the MCP server on that host".into());
|
||||
return Err("not supported for remote projects yet".into());
|
||||
}
|
||||
let projects = self.0.projects.read();
|
||||
let open = || projects.iter().filter(|(_, p)| !p.light);
|
||||
|
||||
@@ -305,7 +305,7 @@ pub fn list_runs() -> Tool {
|
||||
start of the command, exit code and times. `get_run_status` gives a tab's whole status.",
|
||||
|call| async move {
|
||||
let page = Page::of(&call, LIST_LIMIT)?;
|
||||
let paths = crate::mcp::search::PathScope::of(&call)?;
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let wanted = call.opt_str("state")?.filter(|s| s != "all");
|
||||
let states = match wanted.as_deref() {
|
||||
None => None,
|
||||
@@ -327,7 +327,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
.rev()
|
||||
.map(|r| r.status())
|
||||
// A tab belongs where its command runs.
|
||||
.filter(|s| paths.matches_dir(&call.root().join(s["workingDirectory"].as_str().unwrap_or_default())))
|
||||
.filter(|s| dir.contains_shown(call.root(), s["workingDirectory"].as_str().unwrap_or_default()))
|
||||
.filter(|s| {
|
||||
states.as_ref().is_none_or(|states| s["state"].as_str().is_some_and(|v| states.contains(&v)))
|
||||
})
|
||||
@@ -344,7 +344,7 @@ start of the command, exit code and times. `get_run_status` gives a tab's whole
|
||||
ParamType::String,
|
||||
"all (default), running, idle (not running), error (failed, crashed, startFailed), or one state",
|
||||
))
|
||||
.param(crate::mcp::search::paths_param())
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Tabs to return at most (default 10)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
|
||||
@@ -139,14 +139,12 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
}
|
||||
let page = Page::of(&call, CONFIGURATIONS_LIMIT)?;
|
||||
let query = call.opt_str("query")?.map(|q| q.to_lowercase());
|
||||
let paths = crate::mcp::search::PathScope::of(&call)?;
|
||||
let dir = crate::mcp::scope::Scope::of(&call)?;
|
||||
let list: Vec<Value> = configs
|
||||
.iter()
|
||||
// A configuration belongs where it runs.
|
||||
.filter(|c| {
|
||||
paths.matches_dir(
|
||||
&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)),
|
||||
)
|
||||
dir.contains(&c.cwd.as_deref().map_or_else(|| call.root().to_path_buf(), |d| call.root().join(d)))
|
||||
})
|
||||
.filter(|c| {
|
||||
query.as_ref().is_none_or(|q| {
|
||||
@@ -171,7 +169,7 @@ the whole command. Run points are found in Rust, JavaScript/TypeScript, Python a
|
||||
in the file instead of project-wide run configurations.",
|
||||
))
|
||||
.param(Param::optional("query", ParamType::String, "Only configurations whose name, type or command contains it"))
|
||||
.param(crate::mcp::search::paths_param())
|
||||
.param(crate::mcp::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Configurations to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
@@ -358,13 +356,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
|
||||
t.drain(..cut);
|
||||
}
|
||||
});
|
||||
let config = match resolve_jvm_application(call, config, errors).await? {
|
||||
Ok(config) => config,
|
||||
Err(reason) => {
|
||||
errors.process_outputs.push(reason);
|
||||
return Ok(false);
|
||||
}
|
||||
};
|
||||
let info = crate::ops::run::run_start(&call.host(), call.window(), config, emit, None).await?;
|
||||
let exit = wait_exit(call, info.id, None).await?.flatten();
|
||||
if exit == Some(0) {
|
||||
@@ -376,177 +367,6 @@ async fn run_to_end(call: &Call, config: RunConfig, errors: &mut BuildErrors) ->
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// Run configuration kinds launched as a JVM main class (`JVM_APPLICATION_KINDS` in the UI).
|
||||
const JVM_APPLICATION_KINDS: [&str; 2] = ["application", "spring-boot"];
|
||||
const CLASSPATH: &str = "${classpath}";
|
||||
const TEST_CLASSPATH: &str = "${testClasspath}";
|
||||
|
||||
/// `java` options whose value is the next argument (`parseJavaArgs` in the UI).
|
||||
const JAVA_OPTIONS_WITH_VALUE: [&str; 13] = [
|
||||
"-cp",
|
||||
"-classpath",
|
||||
"--class-path",
|
||||
"-p",
|
||||
"--module-path",
|
||||
"--upgrade-module-path",
|
||||
"--add-modules",
|
||||
"--add-opens",
|
||||
"--add-exports",
|
||||
"--add-reads",
|
||||
"--patch-module",
|
||||
"--limit-modules",
|
||||
"--enable-native-access",
|
||||
];
|
||||
|
||||
/// The main class of `java` arguments and which classpath placeholder they use (`Some(true)`:
|
||||
/// `${testClasspath}`; `None`: an explicit classpath or none).
|
||||
fn java_main_class(args: &[String]) -> (Option<&str>, Option<bool>) {
|
||||
let mut test = None;
|
||||
let mut i = 0;
|
||||
while i < args.len() {
|
||||
let a = args[i].as_str();
|
||||
if a == "-jar" {
|
||||
return (None, test);
|
||||
}
|
||||
if matches!(a, "-cp" | "-classpath" | "--class-path") {
|
||||
match args.get(i + 1).map(String::as_str) {
|
||||
Some(CLASSPATH) => test = Some(false),
|
||||
Some(TEST_CLASSPATH) => test = Some(true),
|
||||
_ => {}
|
||||
}
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if JAVA_OPTIONS_WITH_VALUE.contains(&a) {
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if !a.starts_with('-') {
|
||||
return (Some(a), test);
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
(None, test)
|
||||
}
|
||||
|
||||
/// `args` with the classpath placeholders replaced and the module path added (`resolveJavaCommand`).
|
||||
fn resolved_java_args(args: &[String], info: &ide_lsp::jdtls::JavaLaunchInfo) -> Vec<String> {
|
||||
let cp = info.class_paths.join(&info.path_list_separator);
|
||||
let mut out = Vec::with_capacity(args.len() + 2);
|
||||
if !info.module_paths.is_empty() && !args.iter().any(|a| a == "-p" || a == "--module-path") {
|
||||
out.push("--module-path".to_owned());
|
||||
out.push(info.module_paths.join(&info.path_list_separator));
|
||||
}
|
||||
out.extend(args.iter().map(|a| if a == CLASSPATH || a == TEST_CLASSPATH { cp.clone() } else { a.clone() }));
|
||||
out
|
||||
}
|
||||
|
||||
/// The module (relative to the project root) of a JVM source file: the part before
|
||||
/// `src/<set>/<language>/` (`jvmModuleDir` without a build model).
|
||||
fn jvm_module_of(rel: &str) -> Option<String> {
|
||||
let rel = rel.replace('\\', "/");
|
||||
let parts: Vec<&str> = rel.split('/').collect();
|
||||
(0..parts.len().saturating_sub(3)).find_map(|i| {
|
||||
(parts[i] == "src" && matches!(parts[i + 2], "java" | "kotlin" | "scala" | "groovy"))
|
||||
.then(|| parts[..i].join("/"))
|
||||
})
|
||||
}
|
||||
|
||||
/// The module of a configuration saved without one, found from its main class's source
|
||||
/// (`findJavaModule`): `None` unless exactly one module declares it.
|
||||
async fn find_java_module(call: &Call, main: &str) -> IdeResult<Option<String>> {
|
||||
let outer = main.split('$').next().unwrap_or(main);
|
||||
let (pkg, simple) = outer.rsplit_once('.').unwrap_or(("", outer));
|
||||
let mut names = vec![format!("{simple}.java"), format!("{simple}.kt")];
|
||||
if let Some(stem) = simple.strip_suffix("Kt") {
|
||||
names.push(format!("{stem}.kt"));
|
||||
}
|
||||
let mut modules = std::collections::BTreeSet::new();
|
||||
for name in names {
|
||||
for path in crate::ops::nav::find_files_named(&call.host(), call.window(), name).await? {
|
||||
let path = std::path::PathBuf::from(path);
|
||||
let Ok(text) = std::fs::read_to_string(&path) else { continue };
|
||||
let declared = text
|
||||
.lines()
|
||||
.map(str::trim)
|
||||
.find_map(|l| l.strip_prefix("package "))
|
||||
.map(|p| p.trim_end_matches(';').trim())
|
||||
.unwrap_or("");
|
||||
if declared != pkg {
|
||||
continue;
|
||||
}
|
||||
let rel = path.strip_prefix(call.root()).unwrap_or(&path).to_string_lossy().into_owned();
|
||||
modules.insert(jvm_module_of(&rel).unwrap_or_default());
|
||||
}
|
||||
}
|
||||
Ok((modules.len() == 1).then(|| modules.into_iter().next().unwrap_or_default()))
|
||||
}
|
||||
|
||||
/// A JVM application configuration ready to start, as the Run tool window launches it:
|
||||
/// built per its before-launch build policy, with `${classpath}` / `${testClasspath}`, the
|
||||
/// module path and the module's `java` resolved through jdtls. `Err` says why it cannot start
|
||||
/// (compile errors are added to `errors`). Other configurations are returned as they are.
|
||||
async fn resolve_jvm_application(
|
||||
call: &Call,
|
||||
config: RunConfig,
|
||||
errors: &mut BuildErrors,
|
||||
) -> IdeResult<Result<RunConfig, String>> {
|
||||
if !JVM_APPLICATION_KINDS.contains(&config.kind.as_str()) {
|
||||
return Ok(Ok(config));
|
||||
}
|
||||
let (main, test) = java_main_class(&config.args);
|
||||
let Some(main) = main.map(str::to_owned) else {
|
||||
return Ok(Err(format!("No main class in '{}'", config.name)));
|
||||
};
|
||||
let module = match config.extras.module.clone() {
|
||||
Some(module) => module,
|
||||
None => match find_java_module(call, &main).await? {
|
||||
Some(module) => module,
|
||||
None => return Ok(Err(format!("Cannot determine the module for main class '{main}'"))),
|
||||
},
|
||||
};
|
||||
let policy = config.extras.build_policy.unwrap_or_default();
|
||||
let cancel = ide_core::CancellationToken::new();
|
||||
let host = call.host();
|
||||
let info = crate::ops::java::resolve_launch(
|
||||
&host,
|
||||
call.window(),
|
||||
std::path::PathBuf::from(&module),
|
||||
test == Some(true),
|
||||
policy,
|
||||
&cancel,
|
||||
)
|
||||
.await?;
|
||||
use ide_lsp::jdtls::JavaBuildStatus;
|
||||
if matches!(info.build, Some(JavaBuildStatus::Failed | JavaBuildStatus::WithErrors))
|
||||
&& policy != ide_run::BuildPolicy::MakeAndContinueOnErrors
|
||||
{
|
||||
for e in &info.errors {
|
||||
errors.errors.push(format!(
|
||||
"{}:{}: {}",
|
||||
std::path::PathBuf::from(e.path.clone()).display(),
|
||||
e.line,
|
||||
e.message
|
||||
));
|
||||
}
|
||||
let reason = if info.build == Some(JavaBuildStatus::Failed) {
|
||||
format!("Build failed; '{}' was not started.", config.name)
|
||||
} else {
|
||||
format!("Build has compile errors; '{}' was not started.", config.name)
|
||||
};
|
||||
return Ok(Err(reason));
|
||||
}
|
||||
if test.is_some() && info.class_paths.is_empty() {
|
||||
return Ok(Err("The classpath is empty: is the module imported by the Java language server?".to_owned()));
|
||||
}
|
||||
let args = resolved_java_args(&config.args, &info);
|
||||
let command = match (&info.java_exec, config.command.as_str()) {
|
||||
(Some(exec), "java") => exec.clone(),
|
||||
_ => config.command.clone(),
|
||||
};
|
||||
Ok(Ok(RunConfig { command, args, ..config }))
|
||||
}
|
||||
|
||||
/// The configuration's before-launch tasks, as the Run tool window runs them; returns why
|
||||
/// the launch is aborted, if it is. Tool windows are not activated.
|
||||
async fn before_launch(
|
||||
@@ -788,10 +608,6 @@ one by one",
|
||||
if let Some(reason) = before_launch(&call, &config, &configs, &mut Vec::new(), &mut errors).await? {
|
||||
return Err(execution_failed(&[errors.text(), Some(reason)]));
|
||||
}
|
||||
let config = match resolve_jvm_application(&call, config, &mut errors).await? {
|
||||
Ok(config) => config,
|
||||
Err(reason) => return Err(execution_failed(&[errors.text(), Some(reason)])),
|
||||
};
|
||||
let collector = Arc::new(Mutex::new(OutputCollector::create(&config.name)?));
|
||||
let output_path = collector.lock().path.clone();
|
||||
let sink = collector.clone();
|
||||
@@ -868,40 +684,6 @@ provided, values are merged over existing env.",
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn strings(args: &[&str]) -> Vec<String> {
|
||||
args.iter().map(|a| (*a).to_owned()).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_arguments_name_the_main_class_and_classpath_placeholder() {
|
||||
let run = strings(&["-Xmx1g", "-cp", CLASSPATH, "--add-opens", "a/b=ALL-UNNAMED", "com.example.App", "x"]);
|
||||
assert_eq!(java_main_class(&run), (Some("com.example.App"), Some(false)));
|
||||
assert_eq!(java_main_class(&strings(&["-classpath", TEST_CLASSPATH, "T"])), (Some("T"), Some(true)));
|
||||
assert_eq!(java_main_class(&strings(&["-cp", "lib/*", "Main"])), (Some("Main"), None));
|
||||
assert_eq!(java_main_class(&strings(&["-jar", "app.jar"])), (None, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolved_java_arguments_replace_the_placeholder_and_add_the_module_path() {
|
||||
let info = ide_lsp::jdtls::JavaLaunchInfo {
|
||||
class_paths: vec!["/p/target/classes".into(), "/m2/a.jar".into()],
|
||||
module_paths: vec!["/m2/mod.jar".into()],
|
||||
path_list_separator: ":".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(
|
||||
resolved_java_args(&strings(&["-cp", CLASSPATH, "App"]), &info),
|
||||
strings(&["--module-path", "/m2/mod.jar", "-cp", "/p/target/classes:/m2/a.jar", "App"])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_source_file_belongs_to_the_module_before_its_source_set() {
|
||||
assert_eq!(jvm_module_of("repro-dto/src/main/java/com/example/App.java").as_deref(), Some("repro-dto"));
|
||||
assert_eq!(jvm_module_of("src/test/kotlin/AppTest.kt").as_deref(), Some(""));
|
||||
assert_eq!(jvm_module_of("scripts/App.java"), None);
|
||||
}
|
||||
|
||||
fn config() -> RunConfig {
|
||||
RunConfig {
|
||||
id: "user:x".into(),
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
//! The `scope` argument of the query tools: the directory their results are limited to, a
|
||||
//! folder of the project or a project attached to it.
|
||||
|
||||
use crate::mcp::tool::{Call, Param, ParamType};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub fn param() -> Param {
|
||||
Param::optional(
|
||||
"scope",
|
||||
ParamType::String,
|
||||
"Directory to limit results to: relative to the project root, or absolute",
|
||||
)
|
||||
}
|
||||
|
||||
/// No `scope`: everything.
|
||||
pub struct Scope(Option<PathBuf>);
|
||||
|
||||
impl Scope {
|
||||
pub fn of(call: &Call) -> IdeResult<Self> {
|
||||
let Some(raw) = call.opt_str("scope")?.filter(|s| !s.trim().is_empty()) else { return Ok(Self(None)) };
|
||||
let given = Path::new(raw.trim());
|
||||
let path = crate::mcp::tool::normalize(&if given.is_absolute() {
|
||||
given.to_path_buf()
|
||||
} else {
|
||||
call.root().join(given)
|
||||
});
|
||||
let roots: Vec<PathBuf> =
|
||||
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
|
||||
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
|
||||
if !ide_vfs::content_path_allowed(&path, &roots) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
if !path.is_dir() {
|
||||
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
|
||||
}
|
||||
if !roots.iter().any(|root| path.starts_with(root)) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
Ok(Self(Some(path)))
|
||||
}
|
||||
|
||||
pub fn dir(&self) -> Option<&Path> {
|
||||
self.0.as_deref()
|
||||
}
|
||||
|
||||
pub fn contains(&self, path: &Path) -> bool {
|
||||
self.0.as_ref().is_none_or(|dir| path.starts_with(dir))
|
||||
}
|
||||
|
||||
/// For a path the tools return: project-relative with `/`, or absolute.
|
||||
pub fn contains_shown(&self, root: &Path, path: &str) -> bool {
|
||||
self.0.is_none() || self.contains(&root.join(path))
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
//! the editor (one per character except emoji and other astral characters).
|
||||
|
||||
use crate::mcp::page::{OFFSET, Page};
|
||||
use crate::mcp::scope::{self, Scope};
|
||||
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use crate::mcp::util::{INDEXING_PARTIAL_RESULT_REASON, MEDIUM_TIMEOUT};
|
||||
use crate::ops::search::SearchEvent;
|
||||
@@ -36,10 +37,8 @@ const MIN_UNMASKED_MATCHES: usize = 10_000;
|
||||
/// outside the window of a longer line are left out.
|
||||
const LINE_WINDOW: usize = 500;
|
||||
|
||||
const INCLUDE_EXCLUDED_DESCRIPTION: &str = "Whether to include excluded/ignored files in results";
|
||||
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results (absolute ones for a \
|
||||
project attached outside it). Supports '!' excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as \
|
||||
'**/pattern'. Empty strings are ignored.";
|
||||
const PATHS_DESCRIPTION: &str = "Optional list of project-relative glob patterns to filter results. Supports '!' \
|
||||
excludes. Trailing '/' expands to '**'. Patterns without '/' are treated as '**/pattern'. Empty strings are ignored.";
|
||||
const LIMIT_DESCRIPTION: &str = "Results to return at most (default 100)";
|
||||
const SYMBOL_LIMIT_DESCRIPTION: &str = "Results to return at most (default 50)";
|
||||
const CONTEXT_DESCRIPTION: &str = "Lines around each match to return besides the matched line (`lineText`): \"+N\" the \
|
||||
@@ -69,8 +68,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, false).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Text to search for"))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
|
||||
@@ -92,8 +91,8 @@ Examples: [\"src/**\", \"!**/test/**\"], [\"**/*.kt\"], [\"foo/\"].",
|
||||
|call| async move { text_search(call, true).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Regex pattern to search for"))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.param(Param::optional("context", ParamType::String, CONTEXT_DESCRIPTION))
|
||||
@@ -114,7 +113,8 @@ If you don't find a suitable result, try again with include_external=true to sea
|
||||
|call| async move { symbol_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Symbol query text"))
|
||||
.param(paths_param())
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional(
|
||||
"include_external",
|
||||
ParamType::Boolean,
|
||||
@@ -140,8 +140,13 @@ Paths are optional additional glob filters relative to the project root.",
|
||||
|call| async move { file_search(call).await },
|
||||
)
|
||||
.param(Param::required("q", ParamType::String, "Glob pattern to search for"))
|
||||
.param(paths_param())
|
||||
.param(Param::optional("includeExcluded", ParamType::Boolean, INCLUDE_EXCLUDED_DESCRIPTION))
|
||||
.param(scope::param())
|
||||
.param(Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION))
|
||||
.param(Param::optional(
|
||||
"includeExcluded",
|
||||
ParamType::Boolean,
|
||||
"Whether to include excluded/ignored files in results",
|
||||
))
|
||||
.param(Param::optional("limit", ParamType::Integer, LIMIT_DESCRIPTION))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
.output(result_schema())
|
||||
@@ -331,39 +336,22 @@ async fn fill_lines(
|
||||
|
||||
// --- path globs ----------------------------------------------------------------
|
||||
|
||||
/// The `paths` argument every query tool takes.
|
||||
pub(crate) fn paths_param() -> Param {
|
||||
Param::optional("paths", ParamType::StringList, PATHS_DESCRIPTION)
|
||||
}
|
||||
|
||||
/// The `paths` argument: project-relative globs (absolute ones in a project attached outside
|
||||
/// the project), `!` excludes. It only narrows: what the project leaves out stays out.
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct PathScope {
|
||||
root: PathBuf,
|
||||
/// The `paths` argument: project-relative globs, `!` excludes.
|
||||
struct PathScope {
|
||||
/// `None` when only excludes were given (everything is included).
|
||||
include: Option<GlobSet>,
|
||||
exclude: GlobSet,
|
||||
/// The globs as `FileMask` masks for Find in Files (`{a,b}` expanded, as masks
|
||||
/// split on commas), `None` when they cannot be expressed.
|
||||
masks: Option<(Vec<String>, Vec<String>)>,
|
||||
/// The folders the included globs lie in, `None` when one may match anywhere (`**/a.rs`).
|
||||
roots: Option<Vec<PathBuf>>,
|
||||
}
|
||||
|
||||
impl PathScope {
|
||||
pub(crate) fn of(call: &Call) -> IdeResult<Self> {
|
||||
Self::new(call.root(), &call.project().content_roots(), &call.str_list("paths")?)
|
||||
}
|
||||
|
||||
/// `attached`: the content roots, whose files outside `root` the globs name by absolute path.
|
||||
fn new(root: &Path, attached: &[PathBuf], patterns: &[String]) -> IdeResult<Self> {
|
||||
fn new(root: &Path, patterns: &[String]) -> IdeResult<Self> {
|
||||
let (mut include, mut exclude) = (GlobSetBuilder::new(), GlobSetBuilder::new());
|
||||
let (mut include_masks, mut exclude_masks) = (Vec::new(), Vec::new());
|
||||
let mut roots = Vec::new();
|
||||
let mut has_include = false;
|
||||
let mut maskable = true;
|
||||
let mut anywhere = false;
|
||||
for raw in patterns {
|
||||
let raw = raw.trim();
|
||||
if raw.is_empty() {
|
||||
@@ -374,18 +362,12 @@ impl PathScope {
|
||||
Some(rest) => (true, rest.trim()),
|
||||
None => (false, raw),
|
||||
};
|
||||
let mut glob = normalize_glob(pattern, root, attached)?;
|
||||
let mut glob = normalize_glob(pattern, root)?;
|
||||
// A path naming an existing directory covers the files below it.
|
||||
if index_of_glob_char(&glob).is_none() && root.join(&glob).is_dir() {
|
||||
glob.push_str("/**");
|
||||
}
|
||||
if !negated {
|
||||
match glob_folder(&glob, root) {
|
||||
Some(folder) => roots.push(folder),
|
||||
None => anywhere = true,
|
||||
}
|
||||
}
|
||||
let alternatives = expand_braces(&engine_mask(&glob, attached));
|
||||
let alternatives = expand_braces(&glob);
|
||||
maskable &= alternatives.is_some();
|
||||
let (set, masks) =
|
||||
if negated { (&mut exclude, &mut exclude_masks) } else { (&mut include, &mut include_masks) };
|
||||
@@ -394,83 +376,27 @@ impl PathScope {
|
||||
has_include |= !negated;
|
||||
}
|
||||
let build = |b: GlobSetBuilder| b.build().map_err(|e| IdeError::invalid(format!("Invalid glob pattern: {e}")));
|
||||
// A folder inside another one is walked with it.
|
||||
roots.sort();
|
||||
roots.dedup_by(|inner, outer| inner.starts_with(outer));
|
||||
Ok(Self {
|
||||
root: root.to_path_buf(),
|
||||
include: if has_include { Some(build(include)?) } else { None },
|
||||
exclude: build(exclude)?,
|
||||
masks: maskable.then_some((include_masks, exclude_masks)),
|
||||
roots: (has_include && !anywhere).then_some(roots),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn is_all(&self) -> bool {
|
||||
fn is_all(&self) -> bool {
|
||||
self.include.is_none() && self.exclude.is_empty()
|
||||
}
|
||||
|
||||
/// `path` is project-relative with `/` (absolute outside the project).
|
||||
pub(crate) fn matches(&self, path: &str) -> bool {
|
||||
fn matches(&self, path: &str) -> bool {
|
||||
self.include.as_ref().is_none_or(|s| s.is_match(path)) && !self.exclude.is_match(path)
|
||||
}
|
||||
|
||||
pub(crate) fn matches_path(&self, path: &Path) -> bool {
|
||||
self.is_all() || self.matches(&shown(&self.root, path))
|
||||
}
|
||||
|
||||
/// Whether `dir` or a file in it is in: a directory something runs in.
|
||||
pub(crate) fn matches_dir(&self, dir: &Path) -> bool {
|
||||
if self.is_all() {
|
||||
return true;
|
||||
}
|
||||
let dir = shown(&self.root, dir);
|
||||
self.matches(&dir) || self.matches(&if dir.is_empty() { "x".into() } else { format!("{dir}/x") })
|
||||
}
|
||||
|
||||
/// The folders to walk instead of the whole project, `None` when a glob may match anywhere.
|
||||
pub(crate) fn roots(&self) -> Option<&[PathBuf]> {
|
||||
self.roots.as_deref()
|
||||
}
|
||||
}
|
||||
|
||||
/// `path` as the tools give it: relative to `root` with `/`, absolute (with `/`) outside it.
|
||||
fn shown(root: &Path, path: &Path) -> String {
|
||||
path.strip_prefix(root).unwrap_or(path).to_string_lossy().replace('\\', "/")
|
||||
}
|
||||
|
||||
/// The folder a normalized glob lies in (the whole segments before its first glob character),
|
||||
/// `None` for one that may match anywhere.
|
||||
fn glob_folder(glob: &str, root: &Path) -> Option<PathBuf> {
|
||||
let end = index_of_glob_char(glob).map_or(glob.len(), |i| glob[..i].rfind('/').unwrap_or(0));
|
||||
let prefix = glob[..end].trim_end_matches('/');
|
||||
if prefix.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(prefix);
|
||||
// A file named by its path lies in its folder.
|
||||
Some(if index_of_glob_char(glob).is_none() && !path.is_dir() { path.parent()?.to_path_buf() } else { path })
|
||||
}
|
||||
|
||||
/// `glob` as Find in Files matches it: a project attached outside the project goes by its
|
||||
/// folder name there (as `search_project` shows its files), not by its absolute path.
|
||||
fn engine_mask(glob: &str, attached: &[PathBuf]) -> String {
|
||||
if is_absolute_pattern(glob) {
|
||||
for root in attached {
|
||||
let shown = root.to_string_lossy().replace('\\', "/");
|
||||
if let Some(rest) = glob.strip_prefix(&shown).filter(|r| r.is_empty() || r.starts_with('/')) {
|
||||
return format!("{}{rest}", root.file_name().unwrap_or_default().to_string_lossy());
|
||||
}
|
||||
}
|
||||
}
|
||||
glob.to_owned()
|
||||
}
|
||||
|
||||
/// A glob as a project-relative pattern: `\` → `/`, leading `./` dropped, `dir/` → `dir/**`,
|
||||
/// `name` → `**/name`, and its leading directories (`..`, absolute paths) resolved against
|
||||
/// `root`; absolute in a project of `attached` outside it. Errors when that points outside the
|
||||
/// project.
|
||||
fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
|
||||
/// `root`. Errors when that points outside the project.
|
||||
fn normalize_glob(raw: &str, root: &Path) -> IdeResult<String> {
|
||||
let mut value = raw.trim().replace('\\', "/");
|
||||
if value.is_empty() {
|
||||
return Err(IdeError::invalid("Glob pattern is empty"));
|
||||
@@ -485,7 +411,7 @@ fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<Str
|
||||
if !value.contains('/') {
|
||||
value = format!("**/{value}");
|
||||
}
|
||||
let value = normalize_path_pattern(&value, root, attached)?;
|
||||
let value = normalize_path_pattern(&value, root)?;
|
||||
if value.is_empty() {
|
||||
return Err(IdeError::invalid(format!("Invalid glob pattern: {raw}")));
|
||||
}
|
||||
@@ -495,7 +421,7 @@ fn normalize_glob(raw: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<Str
|
||||
/// Resolves the whole directory segments before the first glob character against `root`.
|
||||
/// (JetBrains resolves up to the glob character itself, turning `src/Foo*.java` into
|
||||
/// `src/Foo/*.java`; only whole segments are resolved here.)
|
||||
fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> IdeResult<String> {
|
||||
fn normalize_path_pattern(pattern: &str, root: &Path) -> IdeResult<String> {
|
||||
let outside = || {
|
||||
IdeError::invalid(format!("Specified path '{pattern}' points to the location outside of the project directory"))
|
||||
};
|
||||
@@ -516,16 +442,8 @@ fn normalize_path_pattern(pattern: &str, root: &Path, attached: &[PathBuf]) -> I
|
||||
} else {
|
||||
root.join(prefix_path)
|
||||
});
|
||||
let relative = relative_to_root(root, &absolute).ok_or_else(outside)?;
|
||||
let suffix = pattern[prefix_len..].trim_start_matches('/');
|
||||
let Some(relative) = relative_to_root(root, &absolute) else {
|
||||
// A project attached outside the project goes by its absolute path, as its files do.
|
||||
let absolute = dunce::canonicalize(&absolute).unwrap_or(absolute);
|
||||
if !attached.iter().any(|r| absolute.starts_with(r)) {
|
||||
return Err(outside());
|
||||
}
|
||||
let absolute = absolute.to_string_lossy().replace('\\', "/");
|
||||
return Ok(if suffix.is_empty() { absolute } else { format!("{absolute}/{suffix}") });
|
||||
};
|
||||
Ok(match (relative.is_empty(), suffix.is_empty()) {
|
||||
(true, _) => suffix.to_owned(),
|
||||
(false, true) => relative,
|
||||
@@ -626,7 +544,8 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
let pattern = query(&call, if is_regex { "Regex pattern is empty" } else { "Search text is empty" })?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
// Globs Find in Files cannot take are applied afterwards, so the engine must not
|
||||
// stop at `limit` matches the filter may drop.
|
||||
let (masks, max_matches) = match scope.masks.clone() {
|
||||
@@ -646,18 +565,22 @@ async fn text_search(call: Call, is_regex: bool) -> IdeResult<Output> {
|
||||
whole_word: false,
|
||||
include,
|
||||
exclude,
|
||||
scope: SearchScope::Project,
|
||||
// Only `scope` is walked.
|
||||
scope: dir.dir().map_or(SearchScope::Project, |d| SearchScope::Directory { path: d.to_path_buf().into() }),
|
||||
max_matches,
|
||||
context: Default::default(),
|
||||
include_excluded: call.flag("includeExcluded", false)?,
|
||||
};
|
||||
if is_regex && let Err(e) = ide_search::match_ranges("", &query) {
|
||||
return Err(IdeError::invalid(format!("Invalid regex pattern: {pattern} ({})", e.message)));
|
||||
}
|
||||
let (files, summary, timed_out) = run_search(&call, query.clone()).await?;
|
||||
// Content roots outside the project are reported by absolute path.
|
||||
let mut files: Vec<(String, FileMatches)> =
|
||||
files.into_iter().map(|f| (call.display(&f.path.0), f)).filter(|(path, _)| scope.matches(path)).collect();
|
||||
let mut files: Vec<(String, FileMatches)> = files
|
||||
.into_iter()
|
||||
.filter(|f| dir.contains(&f.path.0))
|
||||
.map(|f| (call.display(&f.path.0), f))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.collect();
|
||||
files.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
// Only these can match a line break.
|
||||
let may_span = is_regex || pattern.contains('\n');
|
||||
@@ -827,35 +750,27 @@ async fn run_search(call: &Call, query: SearchQuery) -> IdeResult<(Vec<FileMatch
|
||||
async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Glob pattern is empty")?;
|
||||
let (page, limit) = page(&call, DEFAULT_LIMIT)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let include_excluded = call.flag("includeExcluded", false)?;
|
||||
let glob = GlobSetBuilder::new()
|
||||
.add(build_glob(&normalize_glob(&q, call.root(), &[])?)?)
|
||||
.add(build_glob(&normalize_glob(&q, call.root())?)?)
|
||||
.build()
|
||||
.map_err(|_| IdeError::invalid(format!("Invalid glob pattern: {q}")))?;
|
||||
// Ignored names and "Exclude files" patterns, which `read_dir` does not flag.
|
||||
let excludes = if include_excluded { None } else { Some(FileMask::new(&[], &call.project().search_excludes())?) };
|
||||
let root = call.root().to_path_buf();
|
||||
let content = call.project().content_roots();
|
||||
// Where a folder's exclusions are matched from: the content root holding it, or the project.
|
||||
let base_of =
|
||||
|dir: &Path| content.iter().filter(|r| dir.starts_with(r)).max_by_key(|r| r.components().count()).cloned();
|
||||
// The folders of `paths`, or the project folder and the content roots its walk does not
|
||||
// cover: those outside it and those inside it that it skips as ignored.
|
||||
let roots: Vec<(PathBuf, PathBuf)> = match scope.roots() {
|
||||
Some(dirs) => dirs
|
||||
.iter()
|
||||
.filter(|d| d.is_dir())
|
||||
.map(|d| (d.clone(), base_of(d).unwrap_or_else(|| root.clone())))
|
||||
.collect(),
|
||||
// `scope`, or the project folder and the content roots its walk does not cover: those
|
||||
// outside it and those inside it that it skips as ignored.
|
||||
let roots: Vec<PathBuf> = match dir.dir() {
|
||||
Some(dir) => vec![dir.to_path_buf()],
|
||||
None => std::iter::once(root.clone())
|
||||
.chain(
|
||||
content
|
||||
.iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r))
|
||||
.cloned(),
|
||||
call.project()
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
.filter(|r| relative_to_root(&root, r).is_none() || ide_index::walk_skips(&root, r)),
|
||||
)
|
||||
.map(|r| (r.clone(), r))
|
||||
.collect(),
|
||||
};
|
||||
let host = call.host();
|
||||
@@ -875,7 +790,7 @@ async fn file_search(call: Call) -> IdeResult<Output> {
|
||||
let (paths, more, timed_out) = host
|
||||
.blocking(move || {
|
||||
let mut found = Vec::new();
|
||||
let more = roots.iter().any(|(dir, base)| walk.dir(dir, base, &mut found));
|
||||
let more = roots.iter().any(|base| walk.dir(base, base, &mut found));
|
||||
if walk.cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
@@ -962,23 +877,23 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let q = query(&call, "Search query is empty")?;
|
||||
let (page, limit) = page(&call, SYMBOL_SEARCH_DEFAULT_LIMIT)?;
|
||||
let around = context(&call)?;
|
||||
let scope = PathScope::of(&call)?;
|
||||
let dir = Scope::of(&call)?;
|
||||
let scope = PathScope::new(call.root(), &call.str_list("paths")?)?;
|
||||
let external = call.flag("include_external", false)?;
|
||||
let host = call.host();
|
||||
let project = call.project().clone();
|
||||
let indexing_before = project.index.status().indexing;
|
||||
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
|
||||
let found = {
|
||||
let (project, q, within) = (project.clone(), q.clone(), scope.clone());
|
||||
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
|
||||
host.blocking(move || {
|
||||
Ok(if within.is_all() {
|
||||
project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool)
|
||||
} else {
|
||||
Ok(match dir {
|
||||
// Filtered in the index: a pool cut before the filter could miss every match.
|
||||
project
|
||||
Some(dir) => project
|
||||
.index
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| within.matches_path(p), &|| false)
|
||||
.unwrap_or_default()
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
|
||||
.unwrap_or_default(),
|
||||
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
|
||||
})
|
||||
})
|
||||
.await?
|
||||
@@ -987,6 +902,7 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
.into_iter()
|
||||
// By the path the other tools give: the index shows a root outside the project by its
|
||||
// folder name, which is no path to read.
|
||||
.filter(|s| dir.contains(&s.path.0))
|
||||
.map(|s| (call.display(&s.path.0), s))
|
||||
.filter(|(path, _)| scope.matches(path))
|
||||
.map(|(path, s)| SearchItem {
|
||||
@@ -1004,11 +920,11 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
roots.extend(crate::mcp::tool::attached_projects(call.root()));
|
||||
for (name, container, location) in symbols {
|
||||
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
|
||||
// Project files (attached projects' too) obey `paths`; library symbols are what was
|
||||
// asked for.
|
||||
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
|
||||
// are what was asked for.
|
||||
let inside = location.uri.is_none()
|
||||
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
|
||||
if inside && !scope.matches(&path) {
|
||||
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
|
||||
continue;
|
||||
}
|
||||
let item = SearchItem {
|
||||
@@ -1083,13 +999,13 @@ mod tests {
|
||||
}
|
||||
|
||||
fn scope(root: &Path, p: &[&str]) -> PathScope {
|
||||
PathScope::new(root, &[], &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
|
||||
PathScope::new(root, &p.iter().map(|s| s.to_string()).collect::<Vec<_>>()).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalizes_globs() {
|
||||
let (_dir, root) = root();
|
||||
let n = |p: &str| normalize_glob(p, &root, &[]);
|
||||
let n = |p: &str| normalize_glob(p, &root);
|
||||
assert_eq!(n("*.rs").unwrap(), "**/*.rs");
|
||||
assert_eq!(n("./foo/bar.txt").unwrap(), "foo/bar.txt");
|
||||
assert_eq!(n("foo/").unwrap(), "foo/**");
|
||||
@@ -1166,33 +1082,9 @@ mod tests {
|
||||
assert!(s.matches("a.rs") && !s.matches("docs/a.md"));
|
||||
assert!(scope(root, &["*.{rs,ts}"]).masks.is_some());
|
||||
assert!(scope(root, &["*.{rs,{ts,js}}"]).masks.is_none());
|
||||
let err = |p: &str| PathScope::new(root, &[], &[p.to_owned()]).err().unwrap().message;
|
||||
let err = |p: &str| PathScope::new(root, &[p.to_owned()]).err().unwrap().message;
|
||||
assert!(err("a[").contains("Invalid glob pattern"));
|
||||
assert!(err("!").contains("Exclude pattern is empty"));
|
||||
assert!(err("../x/**").contains("outside of the project directory"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_name_the_folders_to_walk_and_projects_attached_outside() {
|
||||
let (dir, root) = root();
|
||||
let roots = |p: &[&str]| scope(&root, p).roots().map(<[PathBuf]>::to_vec);
|
||||
// Only the folders the globs lie in, a folder inside another one walked with it.
|
||||
assert_eq!(roots(&["subdir1/**", "subdir1/nested/*.rs", "!**/gen/**"]), Some(vec![root.join("subdir1")]));
|
||||
assert_eq!(roots(&["subdir1/nested/x.rs"]), Some(vec![root.join("subdir1/nested")]));
|
||||
// A glob matching anywhere, or none included, means the whole project.
|
||||
assert_eq!(roots(&["subdir1/**", "**/*.rs"]), None);
|
||||
assert_eq!(roots(&["!**/*.md"]), None);
|
||||
|
||||
let attached = dunce::canonicalize(dir.path()).unwrap().join("attached");
|
||||
std::fs::create_dir_all(attached.join("src")).unwrap();
|
||||
let shown = attached.to_string_lossy().replace('\\', "/");
|
||||
let s = PathScope::new(&root, std::slice::from_ref(&attached), &[format!("{shown}/src/**")]).unwrap();
|
||||
assert!(s.matches(&format!("{shown}/src/a.rs")) && !s.matches("src/a.rs"));
|
||||
assert!(s.matches_path(&attached.join("src/a.rs")));
|
||||
assert_eq!(s.roots(), Some(&[attached.join("src")][..]));
|
||||
// Find in Files shows such a project's files under its folder name.
|
||||
assert_eq!(s.masks.unwrap().0, ["attached/src/**"]);
|
||||
let unattached = PathScope::new(&root, &[], &[format!("{shown}/src/**")]);
|
||||
assert!(unattached.err().unwrap().message.contains("outside of the project directory"));
|
||||
}
|
||||
}
|
||||
@@ -1,296 +0,0 @@
|
||||
//! Agents › IDE MCP Server: runs `ide_mcp::McpServer` over built-in host tools
|
||||
//! while `mcpServer.enabled` is on, and reports where it listens.
|
||||
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeResult, IpcPath};
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::net::IpAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
/// The server while it runs, or why it doesn't.
|
||||
#[derive(Default)]
|
||||
pub struct McpService {
|
||||
server: Mutex<Option<ide_mcp::McpServer>>,
|
||||
/// The address, port and token settings the running server was started with.
|
||||
running_with: Mutex<Option<Listen>>,
|
||||
error: Mutex<Option<String>>,
|
||||
/// A link to this executable advertised for `--mcp-stdio` instead of `current_exe()`.
|
||||
stdio_link: RwLock<Option<PathBuf>>,
|
||||
}
|
||||
|
||||
/// What the address, port and token settings ask the server for.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
struct Listen {
|
||||
/// `mcpServer.address`.
|
||||
address: IpAddr,
|
||||
/// `mcpServer.port` with `mcpServer.fixedPort`; otherwise a free port.
|
||||
port: Option<u16>,
|
||||
fixed_token: bool,
|
||||
}
|
||||
|
||||
impl McpService {
|
||||
/// Advertises `link` in `--mcp-stdio` client configs and agent sessions, pointed at this
|
||||
/// executable whenever the server starts. Without one (or where it can't be written),
|
||||
/// `current_exe()` is advertised.
|
||||
pub fn set_stdio_link(&self, link: PathBuf) {
|
||||
*self.stdio_link.write() = Some(link);
|
||||
}
|
||||
|
||||
pub(crate) fn stdio_executable(&self) -> PathBuf {
|
||||
self.stdio_link.read().clone().or_else(|| std::env::current_exe().ok()).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn update_stdio_link(&self) {
|
||||
let mut link = self.stdio_link.write();
|
||||
if let Some(path) = link.as_deref()
|
||||
&& let Err(e) = point_at_current_exe(path)
|
||||
{
|
||||
tracing::warn!("MCP server: cannot link {} ({e}); advertising this executable", path.display());
|
||||
*link = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts, stops or restarts the server to match the global `mcpServer` settings:
|
||||
/// `enabled`, and the address, port and token it listens with.
|
||||
pub fn apply(&self, host: &Arc<Host>) {
|
||||
let settings = host.global_settings.effective().mcp_server;
|
||||
let mut server = self.server.lock();
|
||||
if !settings.enabled {
|
||||
let was_running = server.take();
|
||||
let stopped = was_running.is_some();
|
||||
if let Some(running) = was_running {
|
||||
running.stop();
|
||||
}
|
||||
*self.running_with.lock() = None;
|
||||
host.set_mcp_executable(None);
|
||||
*self.error.lock() = None;
|
||||
drop(server);
|
||||
if stopped {
|
||||
for project in host.projects() {
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
let Ok(address) = settings.address.trim().parse::<IpAddr>() else {
|
||||
let stopped = server.take().map(|running| running.stop()).is_some();
|
||||
*self.running_with.lock() = None;
|
||||
host.set_mcp_executable(None);
|
||||
*self.error.lock() = Some(format!("the listen address `{}` is not an IP address", settings.address.trim()));
|
||||
drop(server);
|
||||
if stopped {
|
||||
for project in host.projects() {
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
return;
|
||||
};
|
||||
let wanted = Listen {
|
||||
address,
|
||||
port: settings.fixed_port.then_some(settings.port).filter(|p| *p != 0),
|
||||
fixed_token: settings.fixed_token,
|
||||
};
|
||||
if server.is_some() && *self.running_with.lock() == Some(wanted) {
|
||||
return;
|
||||
}
|
||||
// Another address, port or token: clients connect anew.
|
||||
if let Some(running) = server.take() {
|
||||
let held = (running.address(), running.port());
|
||||
running.stop();
|
||||
if let Some(port) = port_to_wait_for(held, wanted.port) {
|
||||
wait_until_free(address, port);
|
||||
}
|
||||
}
|
||||
let token = if wanted.fixed_token {
|
||||
match ide_mcp::kept_token(&ide_mcp::token_path(&host.data_dir)) {
|
||||
Ok(token) => Some(token),
|
||||
Err(e) => {
|
||||
tracing::warn!("MCP server: cannot keep the token ({e}); using a new one for this run");
|
||||
None
|
||||
}
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let discovery = ide_mcp::discovery_path(&host.data_dir);
|
||||
match ide_mcp::McpServer::start_with(
|
||||
Arc::new(crate::mcp::Registry::new(host.clone())),
|
||||
Some(discovery),
|
||||
&host.runtime,
|
||||
ide_mcp::ServerOptions { address: Some(address), port: wanted.port, token },
|
||||
) {
|
||||
Ok(started) => {
|
||||
self.update_stdio_link();
|
||||
host.set_mcp_executable(Some(self.stdio_executable()));
|
||||
*server = Some(started);
|
||||
*self.running_with.lock() = Some(wanted);
|
||||
*self.error.lock() = None;
|
||||
drop(server);
|
||||
for project in host.projects() {
|
||||
project.agents.notify_mcp_servers_changed();
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
tracing::warn!("MCP server: {e}");
|
||||
host.set_mcp_executable(None);
|
||||
*self.running_with.lock() = None;
|
||||
*self.error.lock() = Some(e.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops the server on exit (its discovery file goes with it).
|
||||
pub fn stop(&self, host: &Host) {
|
||||
host.set_mcp_executable(None);
|
||||
if let Some(server) = self.server.lock().take() {
|
||||
server.stop();
|
||||
}
|
||||
*self.running_with.lock() = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// Replaces the symlink `link` with one to this executable.
|
||||
fn point_at_current_exe(link: &std::path::Path) -> std::io::Result<()> {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let exe = std::env::current_exe()?;
|
||||
let dir = link.parent().ok_or_else(|| std::io::Error::other("no parent directory"))?;
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let tmp = dir.join(format!(".openidea-server.{}", std::process::id()));
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
std::os::unix::fs::symlink(&exe, &tmp)?;
|
||||
std::fs::rename(&tmp, link).inspect_err(|_| {
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
})
|
||||
}
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let _ = link;
|
||||
Err(std::io::ErrorKind::Unsupported.into())
|
||||
}
|
||||
}
|
||||
|
||||
/// The port a restart listening on `wanted` waits for after stopping the server that listened
|
||||
/// on `held`: only its own, at any address (`127.0.0.1` and `0.0.0.0` overlap). A port another
|
||||
/// program holds (the run fell back to a free one) stays taken, and waiting for it would block
|
||||
/// the window.
|
||||
fn port_to_wait_for(held: (IpAddr, u16), wanted: Option<u16>) -> Option<u16> {
|
||||
wanted.filter(|port| held.1 == *port)
|
||||
}
|
||||
|
||||
/// Waits briefly for a stopped server's port to close, so the restart gets it again.
|
||||
fn wait_until_free(address: IpAddr, port: u16) {
|
||||
for _ in 0..100 {
|
||||
if std::net::TcpListener::bind((address, port)).is_ok() {
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(20));
|
||||
}
|
||||
}
|
||||
|
||||
/// What Settings › Agents › IDE MCP Server shows.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct McpServerStatus {
|
||||
pub running: bool,
|
||||
/// Why it isn't running though turned on.
|
||||
pub error: Option<String>,
|
||||
/// The address listened on (`0.0.0.0` / `::`: every address).
|
||||
pub address: Option<String>,
|
||||
pub port: Option<u16>,
|
||||
/// Why the fixed port (`mcpServer.port`) isn't the one listened on: it was in use or
|
||||
/// reserved, so a free port was taken for this run.
|
||||
pub port_unavailable: Option<String>,
|
||||
/// The window's project, which the URL and command below are for.
|
||||
pub project: Option<IpcPath>,
|
||||
/// `http://<address>:<port>/mcp?project=<root>`, with loopback for every address.
|
||||
pub url: Option<String>,
|
||||
/// Bearer token of `url` (changes with every run unless `mcpServer.fixedToken` is on).
|
||||
pub token: Option<String>,
|
||||
/// The stdio bridge: this host's executable and its arguments.
|
||||
pub stdio_command: Vec<String>,
|
||||
}
|
||||
|
||||
#[command(trust = outside_restricted)]
|
||||
pub fn mcp_server_status(host: &Host, window: &str) -> IdeResult<McpServerStatus> {
|
||||
let root: Option<PathBuf> = host.project(window).ok().filter(|p| !p.light).map(|p| p.root.clone());
|
||||
let server = host.mcp.server.lock();
|
||||
let exe = host.mcp.stdio_executable();
|
||||
Ok(McpServerStatus {
|
||||
running: server.is_some(),
|
||||
error: host.mcp.error.lock().clone(),
|
||||
address: server.as_ref().map(|s| s.address().to_string()),
|
||||
port: server.as_ref().map(|s| s.port()),
|
||||
port_unavailable: server.as_ref().and_then(|s| s.port_unavailable().map(str::to_owned)),
|
||||
url: server.as_ref().zip(root.as_ref()).map(|(s, r)| s.url(r)),
|
||||
token: server.as_ref().map(|s| s.token().to_owned()),
|
||||
stdio_command: root.as_ref().map(|r| ide_mcp::stdio_command(&exe, r)).unwrap_or_default(),
|
||||
project: root.map(IpcPath::from),
|
||||
})
|
||||
}
|
||||
|
||||
/// Settings › Agents › IDE MCP Server › Regenerate Token: forgets the kept token, and restarts the
|
||||
/// server with a new one. Clients configured with the old token stop working.
|
||||
#[command(trust = outside_restricted)]
|
||||
pub fn mcp_regenerate_token(host: &Arc<Host>) -> IdeResult<()> {
|
||||
match std::fs::remove_file(ide_mcp::token_path(&host.data_dir)) {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
*host.mcp.running_with.lock() = None;
|
||||
host.mcp.apply(host);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_ui_ready(host: &Host, window: &str, ready: bool) -> IdeResult<()> {
|
||||
let window = host.owner_window(window);
|
||||
host.project(window)?;
|
||||
host.mcp_requests.set_ready(window, ready);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The user closed the Run tool window tab of an agent command (`run_command`).
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_agent_run_closed(host: &Host, window: &str, name: String) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.mcp_agent_runs.closed(&project.root, &name);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn mcp_respond(host: &Host, window: &str, id: u32, allow: bool, error: Option<String>) -> IdeResult<()> {
|
||||
host.mcp_requests.answer(host.owner_window(window), id, allow, error)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::net::Ipv4Addr;
|
||||
|
||||
#[test]
|
||||
fn a_restart_waits_only_for_the_port_the_stopped_server_held() {
|
||||
let local = IpAddr::V4(Ipv4Addr::LOCALHOST);
|
||||
let any = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
|
||||
assert_eq!(port_to_wait_for((local, 64342), Some(64342)), Some(64342));
|
||||
// Another address on the same port overlaps the old listener: wait for it too.
|
||||
assert_eq!(port_to_wait_for((any, 64342), Some(64342)), Some(64342));
|
||||
// The fixed port was taken by another program: the server ran on a free one.
|
||||
assert_eq!(port_to_wait_for((local, 51234), Some(64342)), None);
|
||||
assert_eq!(port_to_wait_for((local, 64342), None), None);
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(
|
||||
mcp:
|
||||
mcp_agent_run_closed,
|
||||
mcp_regenerate_token,
|
||||
mcp_respond,
|
||||
mcp_server_status,
|
||||
mcp_ui_ready,
|
||||
);
|
||||
@@ -214,7 +214,7 @@ pub fn find_references() -> Tool {
|
||||
Tool::new("find_references", "Find references using the language service and the IDE's project index. Positions are 1-based UTF-16. Reports incomplete results when analysis is still running.", |call| async move {
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let page = super::page::Page::of(&call, REFERENCES_LIMIT)?;
|
||||
let paths = super::search::PathScope::of(&call)?;
|
||||
let dir = super::scope::Scope::of(&call)?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
let request = super::tool::request_id();
|
||||
let work = crate::ops::lsp::lsp_references(&call.host, &call.window, request, opened.doc, opened.pos, call.flag("includeDeclaration", true)?, true, false, crate::ops::Channel::new(|_| {}));
|
||||
@@ -237,8 +237,8 @@ pub fn find_references() -> Tool {
|
||||
if let serde_json::Value::Object(map) = &mut value {
|
||||
let mut list = |key: &str| match map.remove(key) { Some(serde_json::Value::Array(items)) => items, _ => Vec::new() };
|
||||
let (mut locations, mut classified) = (list("locations"), list("classified"));
|
||||
if !paths.is_all() {
|
||||
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| paths.matches_path(std::path::Path::new(p)));
|
||||
if dir.dir().is_some() {
|
||||
let inside = |l: &serde_json::Value| l["path"].as_str().is_some_and(|p| dir.contains(std::path::Path::new(p)));
|
||||
locations.retain(inside);
|
||||
classified.retain(|c| inside(&c["location"]));
|
||||
}
|
||||
@@ -253,7 +253,7 @@ pub fn find_references() -> Tool {
|
||||
.param(Param::required("line", ParamType::Integer, "1-based line"))
|
||||
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
|
||||
.param(Param::optional("includeDeclaration", ParamType::Boolean, "Include declarations (default true)"))
|
||||
.param(super::search::paths_param())
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "References to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
@@ -336,7 +336,7 @@ pub fn get_call_hierarchy() -> Tool {
|
||||
.param(Param::required("line", ParamType::Integer, "1-based line"))
|
||||
.param(Param::required("column", ParamType::Integer, "1-based UTF-16 column"))
|
||||
.param(Param::optional("direction", ParamType::String, "incoming (callers, default) or outgoing (callees)"))
|
||||
.param(super::search::paths_param())
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Items to return at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, super::page::OFFSET))
|
||||
}
|
||||
@@ -354,7 +354,7 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
|
||||
Some(_) => return Err(IdeError::invalid("direction must be incoming or outgoing")),
|
||||
};
|
||||
let page = super::page::Page::of(&call, CALLS_LIMIT)?;
|
||||
let paths = super::search::PathScope::of(&call)?;
|
||||
let scope = super::scope::Scope::of(&call)?;
|
||||
let path = call.resolve_readable(&call.str("filePath")?).await?;
|
||||
let opened = open_at(&call, path).await?;
|
||||
let hierarchy_at = |pos| {
|
||||
@@ -378,8 +378,8 @@ async fn call_hierarchy(call: Call) -> IdeResult<Output> {
|
||||
}
|
||||
result => result?,
|
||||
};
|
||||
if !paths.is_all() {
|
||||
found.items.retain(|i| i.uri.is_none() && paths.matches_path(&i.path.0));
|
||||
if scope.dir().is_some() {
|
||||
found.items.retain(|i| i.uri.is_none() && scope.contains(&i.path.0));
|
||||
}
|
||||
let incomplete = found.incomplete;
|
||||
let (mut root, items) = call_items(found, |p| call.display(p));
|
||||
|
||||
@@ -236,7 +236,7 @@ impl Tool {
|
||||
destructive: false,
|
||||
output_schema: None,
|
||||
input_schema: json!({ "type": "object", "properties": {
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Defaults to the connection's project (`?project=`) or the only open one." }
|
||||
"projectPath": { "type": "string", "description": "Any directory inside an open project. Optional when only one project is open." }
|
||||
}, "required": [] }),
|
||||
},
|
||||
handler: Arc::new(move |call| Box::pin(handler(call))),
|
||||
|
||||
@@ -266,39 +266,33 @@ By default all Git repositories are returned.",
|
||||
.map(|r| (r.root.into_path_buf(), r.head))
|
||||
.collect();
|
||||
let wanted = call.opt_str("repositoryPathRelativeToProject")?;
|
||||
let paths = super::search::PathScope::of(&call)?;
|
||||
let scope = super::scope::Scope::of(&call)?;
|
||||
let git = git_executable(&call);
|
||||
// The repository asked for, or those holding the folders of `paths`.
|
||||
let targets: Vec<PathBuf> = match &wanted {
|
||||
Some(wanted) => vec![call.resolve_inside(wanted)?],
|
||||
None => paths.roots().map(<[PathBuf]>::to_vec).unwrap_or_default(),
|
||||
// A repository asked for, or the one holding `scope`.
|
||||
let target = match &wanted {
|
||||
Some(wanted) => Some(call.resolve_inside(wanted)?),
|
||||
None => scope.dir().map(Path::to_path_buf),
|
||||
};
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = if targets.is_empty() {
|
||||
repos
|
||||
} else {
|
||||
let mut picked: Vec<(PathBuf, Option<String>)> = Vec::new();
|
||||
for path in targets {
|
||||
let mut roots: Vec<(PathBuf, Option<String>)> = match target {
|
||||
None => repos,
|
||||
Some(path) => {
|
||||
// The innermost repository containing the path.
|
||||
let repo = match innermost_repo(repos.clone(), &path) {
|
||||
Some(repo) => repo,
|
||||
match innermost_repo(repos, &path) {
|
||||
Some(repo) => vec![repo],
|
||||
None => match find_git_root(call.root(), &path) {
|
||||
Some(root) => {
|
||||
// JetBrains reads the branch of any repository it reports.
|
||||
let (git, dir) = (git.clone(), root.clone());
|
||||
let branch = host.blocking(move || Ok(read_branch(&git, &dir))).await?;
|
||||
(root, branch)
|
||||
vec![(root, branch)]
|
||||
}
|
||||
None => {
|
||||
let shown = wanted.clone().unwrap_or_else(|| call.display(&path));
|
||||
let shown = wanted.unwrap_or_else(|| call.display(&path));
|
||||
return Err(IdeError::not_found(format!("No git repository found for path: {shown}")));
|
||||
}
|
||||
},
|
||||
};
|
||||
if !picked.iter().any(|p| p.0 == repo.0) {
|
||||
picked.push(repo);
|
||||
}
|
||||
}
|
||||
picked
|
||||
};
|
||||
roots.sort_by_key(|r| relative_to_project(&call, &r.0));
|
||||
let mut repositories = Vec::new();
|
||||
@@ -311,7 +305,7 @@ By default all Git repositories are returned.",
|
||||
.map_err(|e| {
|
||||
IdeError::internal(format!("Failed to get git status for repository '{rel}': {}", e.message))
|
||||
})?;
|
||||
entries.retain(|e| paths.matches_path(&root.join(e.path.trim_end_matches('/'))));
|
||||
entries.retain(|e| scope.contains(&root.join(e.path.trim_end_matches('/'))));
|
||||
let count = |f: fn(&StatusEntry) -> bool| entries.iter().filter(|e| f(e)).count();
|
||||
let listed: Vec<Value> = entries
|
||||
.iter()
|
||||
@@ -358,7 +352,7 @@ By default all Git repositories are returned.",
|
||||
))
|
||||
.param(Param::optional("includeUntracked", ParamType::Boolean, "Whether to include untracked files"))
|
||||
.param(Param::optional("includeIgnored", ParamType::Boolean, "Whether to include ignored files"))
|
||||
.param(super::search::paths_param())
|
||||
.param(super::scope::param())
|
||||
.param(Param::optional("limit", ParamType::Integer, "Entries to return per repository at most (default 100)"))
|
||||
.param(Param::optional("offset", ParamType::Integer, OFFSET))
|
||||
}
|
||||
|
||||
@@ -268,24 +268,6 @@ pub async fn agent_prompt(host: &Host, window: &str, task: String, prompt: Agent
|
||||
host.project(window)?.agents.prompt(&task, prompt, now).await
|
||||
}
|
||||
|
||||
/// Runs a `!` line of the composer in the task's folder with the user's shell, without
|
||||
/// starting a turn; its output goes to the agent with the next message.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_shell(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
command: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
let agents = host.project(window)?.agents.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let result = agents.run_shell(&task, &command, cancel).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// Answers a non-blocking question, without cancelling the current turn.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_answer_question(
|
||||
@@ -387,21 +369,10 @@ pub async fn agent_delete(host: &Host, window: &str, task: String, remove_worktr
|
||||
host.project(window)?.agents.delete(&task, remove_worktree).await
|
||||
}
|
||||
|
||||
/// The task's changed files as `view` compares them (without: since it started).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_changes(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Vec<AgentChange>> {
|
||||
pub async fn agent_changes(host: &Host, window: &str, task: String) -> IdeResult<Vec<AgentChange>> {
|
||||
host.require_trust(window)?;
|
||||
let agents = &host.project(window)?.agents;
|
||||
match view.unwrap_or_default() {
|
||||
AgentChangesView::SinceStart => agents.changes(&task).await,
|
||||
AgentChangesView::Group => Ok(agents.grouped_changes(&task).await?.uncommitted),
|
||||
AgentChangesView::LastTurn => agents.turn_changes(&task).await,
|
||||
}
|
||||
host.project(window)?.agents.changes(&task).await
|
||||
}
|
||||
|
||||
/// The task's uncommitted changes and the commits made since it started.
|
||||
@@ -411,17 +382,11 @@ pub async fn agent_grouped_changes(host: &Host, window: &str, task: String) -> I
|
||||
host.project(window)?.agents.grouped_changes(&task).await
|
||||
}
|
||||
|
||||
/// Content of `path` as `view` compares it (without: when the task started), the left side of its diff.
|
||||
/// Content of `path` when the task started (left side of its diff).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_base_text(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
task: String,
|
||||
path: IpcPath,
|
||||
view: Option<AgentChangesView>,
|
||||
) -> IdeResult<Option<String>> {
|
||||
pub async fn agent_base_text(host: &Host, window: &str, task: String, path: IpcPath) -> IdeResult<Option<String>> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.base_text(&task, path.into_path_buf(), view.unwrap_or_default()).await
|
||||
host.project(window)?.agents.base_text(&task, path.into_path_buf()).await
|
||||
}
|
||||
|
||||
/// Rollback: the task's changed files among `paths` (all without) back as `view` compares them.
|
||||
@@ -1098,7 +1063,6 @@ ide_command::domain!(
|
||||
agent_rollback_changes,
|
||||
agent_send_queued_now,
|
||||
agent_set_command,
|
||||
agent_shell,
|
||||
agent_set_config,
|
||||
agent_set_env,
|
||||
agent_set_mcp_overrides,
|
||||
|
||||
@@ -815,15 +815,7 @@ pub async fn build_run(
|
||||
if compile::menu_up_to_date(&cache, &root, &model, file.as_deref(), &token) {
|
||||
let started = std::time::Instant::now();
|
||||
let plan = prepare_plan(
|
||||
compile::plan(
|
||||
&root,
|
||||
&model,
|
||||
kind,
|
||||
file.as_deref(),
|
||||
settings.cmake.profiles.as_deref(),
|
||||
None,
|
||||
&token,
|
||||
)?,
|
||||
compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
|
||||
&root,
|
||||
&settings,
|
||||
);
|
||||
@@ -861,15 +853,7 @@ pub async fn build_run(
|
||||
if member == &root { cache.clone() } else { cache.join(crate::project::project_key(member)) };
|
||||
let model = with_profiles(load(member, &member_cache, &settings), &member_cache);
|
||||
let plan = prepare_plan(
|
||||
compile::plan(
|
||||
member,
|
||||
&model,
|
||||
kind,
|
||||
file.as_deref(),
|
||||
settings.cmake.profiles.as_deref(),
|
||||
None,
|
||||
&token,
|
||||
)?,
|
||||
compile::plan(member, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?,
|
||||
member,
|
||||
&settings,
|
||||
);
|
||||
@@ -883,15 +867,7 @@ pub async fn build_run(
|
||||
plan
|
||||
} else {
|
||||
let model = with_profiles(load(&root, &cache, &settings), &cache);
|
||||
match compile::plan(
|
||||
&root,
|
||||
&model,
|
||||
kind,
|
||||
file.as_deref(),
|
||||
settings.cmake.profiles.as_deref(),
|
||||
Some(&cache),
|
||||
&token,
|
||||
) {
|
||||
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
|
||||
Ok(plan) => prepare_plan(plan, &root, &settings),
|
||||
// No build tool: a Java project builds from its Project Structure.
|
||||
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
|
||||
@@ -906,11 +882,6 @@ pub async fn build_run(
|
||||
if result.success && single && kind == BuildKind::Build {
|
||||
let model = with_profiles(load(&root, &cache, &settings), &cache);
|
||||
compile::record_menu_build(&cache, &root, &model, file.as_deref(), &token);
|
||||
// Only a project build covers every changed module; after Build Module the
|
||||
// others may still be stale.
|
||||
if file.is_none() {
|
||||
compile::record_module_build(&cache, &root, &model, &token);
|
||||
}
|
||||
}
|
||||
for (path, items) in compile::diagnostics(&result.messages) {
|
||||
sink.emit(IdeEvent::Diagnostics { path: path.into(), source: compile::DIAGNOSTICS_SOURCE.into(), items });
|
||||
@@ -1044,16 +1015,7 @@ mod build_tool_settings_tests {
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join(marker), source).unwrap();
|
||||
let plan = prepare_plan(
|
||||
compile::plan(
|
||||
&dir,
|
||||
&Default::default(),
|
||||
BuildKind::Artifacts,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
&ide_core::CancellationToken::new(),
|
||||
)
|
||||
.unwrap(),
|
||||
compile::plan(&dir, &Default::default(), BuildKind::Artifacts, None, None).unwrap(),
|
||||
root,
|
||||
&settings,
|
||||
);
|
||||
@@ -1127,9 +1089,7 @@ mod build_tool_settings_tests {
|
||||
let expected = root.join(if runner.is_empty() { "project-jdk" } else { runner });
|
||||
let model = load(&root, &root.join("cache"), &settings);
|
||||
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
|
||||
let plan =
|
||||
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
|
||||
.unwrap();
|
||||
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
|
||||
assert!(!plan.steps.is_empty());
|
||||
for step in plan.steps {
|
||||
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
|
||||
@@ -1161,9 +1121,7 @@ mod build_tool_settings_tests {
|
||||
let expected = root.join(name);
|
||||
let model = load(&root, &root.join("cache"), &settings);
|
||||
assert_eq!(model.maven.as_ref().unwrap().projects[0].env["JAVA_HOME"], expected.to_string_lossy());
|
||||
let plan =
|
||||
compile::plan(&root, &model, BuildKind::Build, None, None, None, &ide_core::CancellationToken::new())
|
||||
.unwrap();
|
||||
let plan = compile::plan(&root, &model, BuildKind::Build, None, None).unwrap();
|
||||
assert!(!plan.steps.is_empty());
|
||||
for step in plan.steps {
|
||||
assert_eq!(step.env["JAVA_HOME"], expected.to_string_lossy());
|
||||
|
||||
@@ -24,34 +24,6 @@ pub struct StatementOutcome {
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_approve_jdbc_source(host: &Host, window: &str, source: DataSource) -> IdeResult<()> {
|
||||
host.project(window)?.db.approve_jdbc_source(&source)
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_jdbc_driver_classes(host: &Host, window: &str, jars: Vec<String>) -> IdeResult<Vec<String>> {
|
||||
host.project(window)?;
|
||||
tokio::task::spawn_blocking(move || ide_db::jdbc_driver_classes(&jars))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_jdbc_drivers(host: &Host, window: &str) -> IdeResult<Vec<ide_db::DbJdbcDriver>> {
|
||||
host.project(window)?.db.jdbc_drivers()
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_save_jdbc_driver(host: &Host, window: &str, driver: ide_db::DbJdbcDriver) -> IdeResult<()> {
|
||||
host.project(window)?.db.save_jdbc_driver(driver)
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_remove_jdbc_driver(host: &Host, window: &str, id: String) -> IdeResult<()> {
|
||||
host.project(window)?.db.remove_jdbc_driver(&id)
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub fn db_sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
|
||||
// The data sources configured for the project (the tree's roots).
|
||||
@@ -167,32 +139,6 @@ pub async fn db_disconnect(host: &Host, window: &str, id: String) -> IdeResult<(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_create_database(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
template: String,
|
||||
statement: String,
|
||||
) -> IdeResult<()> {
|
||||
// Creates a database on the server of data source `id` with `statement`, copied from `template` (New › Database).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.create_database(&id, &template, &statement).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_drop_database(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: String,
|
||||
database: String,
|
||||
statement: String,
|
||||
) -> IdeResult<()> {
|
||||
// Drops `database` of the server of data source `id` with `statement` (Drop… on a database node).
|
||||
let db = host.project(window)?.db.clone();
|
||||
db.drop_database(&id, &database, &statement).await
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
pub async fn db_databases(host: &Host, window: &str, id: String) -> IdeResult<Databases> {
|
||||
// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
|
||||
@@ -532,21 +478,14 @@ ide_command::domain!(
|
||||
db_connected,
|
||||
db_console_path,
|
||||
db_consoles,
|
||||
db_create_database,
|
||||
db_database_catalog,
|
||||
db_databases,
|
||||
db_ddl,
|
||||
db_disconnect,
|
||||
db_drop_database,
|
||||
db_execute,
|
||||
db_explain,
|
||||
db_finish_transaction,
|
||||
db_history,
|
||||
db_jdbc_driver_classes,
|
||||
db_jdbc_drivers,
|
||||
db_approve_jdbc_source,
|
||||
db_save_jdbc_driver,
|
||||
db_remove_jdbc_driver,
|
||||
db_object_ddl,
|
||||
db_remove_history,
|
||||
db_retain_catalog,
|
||||
|
||||
@@ -113,11 +113,7 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
})
|
||||
.await?;
|
||||
}
|
||||
let java_analyzer = java_analyzer_command(host, window, &config)?;
|
||||
let custom = |command: &str| {
|
||||
if let Some(binary) = java_analyzer {
|
||||
return Some(binary.to_string_lossy().into_owned());
|
||||
}
|
||||
let path = ide_sdk::apply::tool_command(&root, &settings, command)
|
||||
.or_else(|| ruby_tools.into_iter().find(|(name, _)| *name == command).map(|(_, path)| path))?;
|
||||
Some(path.to_string_lossy().into_owned())
|
||||
@@ -146,28 +142,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
result
|
||||
}
|
||||
|
||||
/// For java-analyzer's debugger, the executable of the java-analyzer serving the module
|
||||
/// (`projectRoot`, else the working directory), so the session debugs with the server that
|
||||
/// analyzes the code.
|
||||
fn java_analyzer_command(host: &Host, window: &str, config: &LaunchConfig) -> IdeResult<Option<PathBuf>> {
|
||||
if config.adapter != ide_dap::adapter::JAVA_ANALYZER {
|
||||
return Ok(None);
|
||||
}
|
||||
let project = host.project(window)?;
|
||||
let extra: serde_json::Value =
|
||||
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok()).unwrap_or_default();
|
||||
let module = extra["projectRoot"]
|
||||
.as_str()
|
||||
.map(PathBuf::from)
|
||||
.or_else(|| config.cwd.clone().map(PathBuf::from))
|
||||
.unwrap_or_else(|| project.root.clone());
|
||||
project.lsp.java_analyzer_binary(&module).map(Some).ok_or_else(|| {
|
||||
ide_core::IdeError::unavailable(
|
||||
"No java-analyzer serves this module: configure it as a Java language server to debug without jdtls",
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn require_unity_editor(pid: u32) -> IdeResult<()> {
|
||||
if !ide_core::process::process_alive(pid) {
|
||||
return Err(ide_core::IdeError::unavailable(format!(
|
||||
@@ -204,16 +178,13 @@ fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port
|
||||
}
|
||||
|
||||
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
|
||||
/// java-debug, java-analyzer or the Kotlin debugger (JAR Application debugs through a run with a
|
||||
/// JDWP agent).
|
||||
/// 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 | ide_dap::adapter::JAVA_ANALYZER)
|
||||
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 and java-analyzer's `vmArgs` (one line, or a list) or the Kotlin debugger's
|
||||
/// `vmArguments` (a list).
|
||||
/// 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;
|
||||
@@ -223,7 +194,7 @@ fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig
|
||||
else {
|
||||
return config;
|
||||
};
|
||||
let key = if config.adapter == ide_dap::kotlin::ADAPTER { "vmArguments" } else { "vmArgs" };
|
||||
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()
|
||||
@@ -357,8 +328,8 @@ pub async fn debug_send_input(host: &Host, session: DebugSessionId, text: String
|
||||
host.debugger.send_input(session, &text)
|
||||
}
|
||||
|
||||
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId, reason: HotReloadReason) -> IdeResult<()> {
|
||||
host.debugger.hot_reload(session, reason).await
|
||||
pub async fn debug_hot_reload(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
host.debugger.hot_reload(session).await
|
||||
}
|
||||
|
||||
pub async fn debug_hot_restart(host: &Host, session: DebugSessionId) -> IdeResult<()> {
|
||||
@@ -764,9 +735,6 @@ mod tests {
|
||||
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]));
|
||||
let java_analyzer =
|
||||
launch(ide_dap::adapter::JAVA_ANALYZER, "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]}));
|
||||
assert_eq!(vm_args(&add_java_agents(java_analyzer, options)), serde_json::json!(["-Xmx1g", agent]));
|
||||
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
|
||||
for config in [
|
||||
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
|
||||
|
||||
@@ -70,18 +70,6 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_autosave(host: &Host, window: &str, doc: DocId) -> IdeResult<bool> {
|
||||
let project = host.project(window)?;
|
||||
let saved = host.blocking(move || project.documents.autosave(doc)).await?;
|
||||
if saved {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await?;
|
||||
}
|
||||
Ok(saved)
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_save_all(host: &Host, window: &str) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
@@ -121,7 +109,6 @@ ide_command::domain!(
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
doc_save_as,
|
||||
doc_snapshot,
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
//! Flutter's devices. The daemon runs on the project host, where `flutter run` and the debug
|
||||
//! adapter run too, so a remote project lists the devices of its remote machine.
|
||||
use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::IdeResult;
|
||||
use ide_core::event::FlutterDeviceList;
|
||||
|
||||
/// The project's Flutter devices, starting its `flutter daemon` on first use. Changes arrive as
|
||||
/// `IdeEvent::FlutterDevices`.
|
||||
#[command(trust = trusted)]
|
||||
pub fn flutter_devices(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
|
||||
Ok(host.project(window)?.flutter.devices())
|
||||
}
|
||||
|
||||
/// Looks at adb again, for Android devices Flutter doesn't report (awaiting authorization, offline).
|
||||
#[command(trust = trusted)]
|
||||
pub fn flutter_devices_refresh(host: &Host, window: &str) -> IdeResult<()> {
|
||||
host.project(window)?.flutter.refresh();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Replaces the project's `flutter daemon`, after a failure or an SDK change.
|
||||
#[command(trust = trusted)]
|
||||
pub fn flutter_daemon_restart(host: &Host, window: &str) -> IdeResult<FlutterDeviceList> {
|
||||
Ok(host.project(window)?.flutter.restart())
|
||||
}
|
||||
|
||||
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart);
|
||||
@@ -3,7 +3,6 @@ use crate::Host;
|
||||
use ide_command::command;
|
||||
use ide_core::{IdeError, IdeResult, RequestId};
|
||||
use ide_vfs::FileEntry;
|
||||
use ide_workspace::DeletionUndo;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[command(trust = always)]
|
||||
@@ -164,27 +163,14 @@ pub fn fs_set_writable(host: &Host, window: &str, path: PathBuf, writable: bool)
|
||||
/// Moving to the trash can take a while (large trees): kept off the main thread.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
delete_with_history(host, window, path, false).await.map(|_| ())
|
||||
}
|
||||
|
||||
/// Moves an item to the Trash and returns the snapshot for Project View Undo.
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_delete_with_undo(host: &Host, window: &str, path: PathBuf) -> IdeResult<DeletionUndo> {
|
||||
delete_with_history(host, window, path, true).await
|
||||
}
|
||||
|
||||
async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable: bool) -> IdeResult<DeletionUndo> {
|
||||
let project = if undoable { Some(host.project(window)?) } else { host.project(window).ok() };
|
||||
// Local History keeps the contents so deleted files can be restored.
|
||||
let project = host.project(window).ok();
|
||||
let history = project.as_ref().map(|p| p.history.clone());
|
||||
host.blocking(move || {
|
||||
let paths = ide_workspace::file_ops::deletion_paths(&path)?;
|
||||
let mut undo = DeletionUndo::default();
|
||||
if let Some(p) = &project {
|
||||
if undoable {
|
||||
undo = p.history.capture_deletion_undo(&paths, DELETE_SNAPSHOT_LIMIT);
|
||||
} else {
|
||||
for pth in &paths {
|
||||
p.history.record_deletion(pth, DELETE_SNAPSHOT_LIMIT);
|
||||
}
|
||||
if let Some(h) = history {
|
||||
for p in &paths {
|
||||
h.record_deletion(p, DELETE_SNAPSHOT_LIMIT);
|
||||
}
|
||||
}
|
||||
ide_workspace::file_ops::delete(&path)?;
|
||||
@@ -192,17 +178,11 @@ async fn delete_with_history(host: &Host, window: &str, path: PathBuf, undoable:
|
||||
if let Some(p) = project {
|
||||
let _ = p.with_backend_of(&path, |r| r.files_deleted(&paths));
|
||||
}
|
||||
Ok(undo)
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_undo_delete(host: &Host, window: &str, undo: DeletionUndo) -> IdeResult<Vec<ide_core::IpcPath>> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || Ok(project.history.restore_deletion_undo(undo))).await
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn fs_copy(host: &Host, window: &str, from: PathBuf, to: PathBuf) -> IdeResult<()> {
|
||||
let project = host.project(window).ok();
|
||||
@@ -300,11 +280,9 @@ ide_command::domain!(
|
||||
fs_create_file,
|
||||
fs_create_file_bytes,
|
||||
fs_delete,
|
||||
fs_delete_with_undo,
|
||||
fs_entry_kind,
|
||||
fs_read_dir,
|
||||
fs_read_text,
|
||||
fs_rename,
|
||||
fs_set_writable,
|
||||
fs_undo_delete,
|
||||
);
|
||||
@@ -311,11 +311,6 @@ async fn shutdown_does_not_wait_forever_for_a_stuck_capture() {
|
||||
shutdown_within(&f.host, std::time::Duration::from_millis(200)).await;
|
||||
assert!(started.elapsed() < std::time::Duration::from_secs(5));
|
||||
assert!(cancel.is_cancelled());
|
||||
// The cleanup is only waited for briefly and finishes in the background on a busy machine.
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
while stuck_dir.exists() && std::time::Instant::now() < deadline {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
|
||||
}
|
||||
assert!(!stuck_dir.exists(), "its directory is removed once the wait is over");
|
||||
}
|
||||
|
||||
|
||||
@@ -5,14 +5,12 @@ use crate::Host;
|
||||
use ide_command::command;
|
||||
|
||||
use super::build::load;
|
||||
use ide_build::BuildModel;
|
||||
use ide_build::compile;
|
||||
use ide_core::error::ErrorKind;
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};
|
||||
use ide_lsp::jdtls::{JavaBuildStatus, JavaLaunchInfo};
|
||||
use ide_run::BuildPolicy;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Cancellable with `cancel_request(request)`.
|
||||
/// Builds according to `policy`, then resolves the runtime (or test)
|
||||
@@ -36,7 +34,7 @@ pub async fn java_resolve_launch(
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) async fn resolve_launch(
|
||||
async fn resolve_launch(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
module: PathBuf,
|
||||
@@ -47,9 +45,6 @@ pub(crate) async fn resolve_launch(
|
||||
let started = std::time::Instant::now();
|
||||
let project = host.project(window)?;
|
||||
let module = project.root.join(module);
|
||||
if !project.lsp.java_served_by_jdtls(&module) {
|
||||
return resolve_launch_without_jdtls(host, &project, module, test, policy, cancel).await;
|
||||
}
|
||||
let settings = project.settings.effective();
|
||||
// A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
|
||||
let build = policy != BuildPolicy::NoBuild;
|
||||
@@ -166,7 +161,35 @@ pub(crate) async fn resolve_launch(
|
||||
}
|
||||
}
|
||||
let compile_ms = started.elapsed().as_millis() - lsp_ms;
|
||||
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
|
||||
// The module/project JDK, else the JDK jdtls compiles the module against, else one matching its Java version.
|
||||
let project_jdk = ide_sdk::apply::module_jdk(&project.root, &module, &settings);
|
||||
let from_jdtls = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
|
||||
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_jdtls).or_else(|| {
|
||||
// The build model's level includes what the module inherits from its parent POMs.
|
||||
let release = model
|
||||
.maven
|
||||
.as_ref()
|
||||
.and_then(|m| m.projects.iter().find(|p| project.root.join(&p.dir) == module))
|
||||
.and_then(|p| p.java_version)
|
||||
.or_else(|| ide_sdk::java::project_java_version(&module));
|
||||
let jdks = ide_sdk::java::installed_jdks();
|
||||
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
|
||||
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
|
||||
});
|
||||
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
|
||||
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
|
||||
let shorten =
|
||||
ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
|
||||
info.shorten_command_line = Some(shorten.as_str().to_owned());
|
||||
if info.error_count > 0 {
|
||||
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
|
||||
let managed = ide_tools::managed_bundle(&data_dir, "lombok");
|
||||
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
|
||||
let root = project.root.clone();
|
||||
// Detection may read the project's sources.
|
||||
let lombok = ide_sdk::lombok::lombok_agent(&root, own, managed, repo);
|
||||
info.hints.extend(lombok.problem());
|
||||
}
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
@@ -183,151 +206,6 @@ pub(crate) async fn resolve_launch(
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// A launch of a module jdtls doesn't serve (another Java language server, or none): the
|
||||
/// build tool compiles it, and the classpath comes from that server, else from Maven.
|
||||
async fn resolve_launch_without_jdtls(
|
||||
host: &Host,
|
||||
project: &std::sync::Arc<crate::Project>,
|
||||
module: PathBuf,
|
||||
test: bool,
|
||||
policy: BuildPolicy,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<JavaLaunchInfo> {
|
||||
let started = std::time::Instant::now();
|
||||
let settings = project.settings.effective();
|
||||
let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
|
||||
let (model, built) = {
|
||||
let (root, cache, settings, module, cancel) =
|
||||
(project.root.clone(), project.build_cache_dir(), settings.clone(), module.clone(), cancel.clone());
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let model = load(&root, &cache, &settings);
|
||||
let built = if policy == BuildPolicy::NoBuild {
|
||||
None
|
||||
} else {
|
||||
Some(compile::build_for_launch(&root, &model, &module, test, kind, &cancel))
|
||||
};
|
||||
(model, built)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
};
|
||||
let mut info =
|
||||
JavaLaunchInfo { path_list_separator: if cfg!(windows) { ";" } else { ":" }.into(), ..Default::default() };
|
||||
let mut class_paths = Vec::new();
|
||||
match built {
|
||||
None => {}
|
||||
Some(Err(e)) if e.kind == ErrorKind::Cancelled => return Err(e),
|
||||
Some(Err(e)) => {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Cannot build the module without jdtls: {}. Running needs a Maven or Gradle build, or jdtls",
|
||||
e.message
|
||||
)));
|
||||
}
|
||||
Some(Ok(built)) => {
|
||||
info.build = Some(match built.failure {
|
||||
None => JavaBuildStatus::Succeeded,
|
||||
Some(failure) if policy == BuildPolicy::MakeAndContinueOnErrors => {
|
||||
info.hints.push(failure);
|
||||
JavaBuildStatus::Failed
|
||||
}
|
||||
Some(failure) => return Err(IdeError::internal(failure)),
|
||||
});
|
||||
class_paths.extend(built.class_dirs.iter().map(|p| p.to_string_lossy().into_owned()));
|
||||
}
|
||||
}
|
||||
let build_ms = started.elapsed().as_millis();
|
||||
let from_server = project.lsp.java_server_classpath(&module, test, cancel).await?;
|
||||
let data_dir = host.local_data_dir.clone();
|
||||
let project = project.clone();
|
||||
let cancel = cancel.clone();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
match from_server {
|
||||
Some(server) => {
|
||||
info.project_root = server.classpath.project_root;
|
||||
info.module_paths = server.classpath.module_paths;
|
||||
info.java_home = server.jdk_home.map(Into::into);
|
||||
append_unique_class_paths(&mut class_paths, server.classpath.class_paths);
|
||||
}
|
||||
None => {
|
||||
let is_maven = model
|
||||
.maven
|
||||
.as_ref()
|
||||
.is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module));
|
||||
if !is_maven {
|
||||
return Err(IdeError::unavailable(
|
||||
"Cannot resolve the classpath: the Java language server does not report it \
|
||||
(java-analyzer/projectClasspath), and the module is not a Maven project",
|
||||
));
|
||||
}
|
||||
let local_repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
|
||||
let classpath = compile::module_classpath(
|
||||
&project.root,
|
||||
&model,
|
||||
&module,
|
||||
test,
|
||||
local_repo,
|
||||
&project.build_cache_dir(),
|
||||
&cancel,
|
||||
)?;
|
||||
append_unique_class_paths(
|
||||
&mut class_paths,
|
||||
std::env::split_paths(&classpath).map(|p| p.to_string_lossy().into_owned()),
|
||||
);
|
||||
}
|
||||
}
|
||||
info.class_paths = class_paths;
|
||||
apply_library_classpath(&mut info, &project.root, &settings.project_structure.libraries, test);
|
||||
finish_launch(&mut info, &project.root, &module, &settings, &model, &data_dir);
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
tracing::info!(build_ms, total_ms = started.elapsed().as_millis(), "Java launch resolved without jdtls");
|
||||
Ok(info)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
}
|
||||
|
||||
/// Picks the `java` launcher and how to shorten its command line, and explains likely
|
||||
/// causes of compile errors.
|
||||
fn finish_launch(
|
||||
info: &mut JavaLaunchInfo,
|
||||
root: &Path,
|
||||
module: &Path,
|
||||
settings: &Settings,
|
||||
model: &BuildModel,
|
||||
data_dir: &Path,
|
||||
) {
|
||||
// The module/project JDK, else the JDK the Java language server builds the module with, else one
|
||||
// matching its Java version.
|
||||
let project_jdk = ide_sdk::apply::module_jdk(root, module, settings);
|
||||
let from_server = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
|
||||
let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_server).or_else(|| {
|
||||
// The build model's level includes what the module inherits from its parent POMs.
|
||||
let release = model
|
||||
.maven
|
||||
.as_ref()
|
||||
.and_then(|m| m.projects.iter().find(|p| root.join(&p.dir) == module))
|
||||
.and_then(|p| p.java_version)
|
||||
.or_else(|| ide_sdk::java::project_java_version(module));
|
||||
let jdks = ide_sdk::java::installed_jdks();
|
||||
info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
|
||||
ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))
|
||||
});
|
||||
info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));
|
||||
let exec = PathBuf::from(info.java_exec.as_deref().unwrap_or("java"));
|
||||
let shorten = ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
|
||||
info.shorten_command_line = Some(shorten.as_str().to_owned());
|
||||
if info.error_count > 0 {
|
||||
let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
|
||||
let managed = ide_tools::managed_bundle(data_dir, "lombok");
|
||||
let repo = ide_sdk::apply::maven_local_repository(root, settings);
|
||||
// Detection may read the project's sources.
|
||||
let lombok = ide_sdk::lombok::lombok_agent(root, own, managed, repo);
|
||||
info.hints.extend(lombok.problem());
|
||||
}
|
||||
}
|
||||
|
||||
/// With Settings › Maven › Delegate IDE build/run actions to Maven, javac's verdict replaces
|
||||
/// JDT's. Classes JDT wrote for sources with errors look up to date to Maven's incremental
|
||||
/// compiler, so a launch JDT reports errors for recompiles everything.
|
||||
@@ -496,21 +374,6 @@ fn use_snapshot_on(
|
||||
copies
|
||||
}
|
||||
|
||||
/// The debug adapter for the JVMs of `module`: `java-debug` inside jdtls, or `java-analyzer`
|
||||
/// (`java-analyzer dap`) when jdtls doesn't serve the module and java-analyzer does.
|
||||
#[command(trust = trusted)]
|
||||
pub fn java_debug_adapter(host: &Host, window: &str, module: PathBuf) -> IdeResult<String> {
|
||||
let project = host.project(window)?;
|
||||
let module = project.root.join(module);
|
||||
let lsp = &project.lsp;
|
||||
Ok(if !lsp.java_served_by_jdtls(&module) && lsp.java_analyzer_binary(&module).is_some() {
|
||||
ide_dap::adapter::JAVA_ANALYZER
|
||||
} else {
|
||||
"java-debug"
|
||||
}
|
||||
.to_owned())
|
||||
}
|
||||
|
||||
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
|
||||
#[command(trust = trusted)]
|
||||
pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {
|
||||
@@ -808,4 +671,4 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
ide_command::domain!(java: java_build_workspace, java_debug_adapter, java_debug_server, java_resolve_launch);
|
||||
ide_command::domain!(java: java_build_workspace, java_debug_server, java_resolve_launch);
|
||||
@@ -359,22 +359,10 @@ pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: Got
|
||||
if kind != GotoKind::Definition {
|
||||
return result;
|
||||
}
|
||||
// A Maven placeholder (`@profileActive@` in `application.yml` or `.properties`) navigates to its pom.
|
||||
let maven = super::maven_placeholder::definition(host, window, doc, pos).await;
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else {
|
||||
return match maven {
|
||||
None => result,
|
||||
Some(found) => {
|
||||
let in_string = in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, vec![found], in_string)
|
||||
}
|
||||
};
|
||||
};
|
||||
let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
|
||||
let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
|
||||
let found: Vec<Location> = maven
|
||||
.into_iter()
|
||||
.chain(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }))
|
||||
.collect();
|
||||
let found: Vec<Location> =
|
||||
found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }).collect();
|
||||
let in_string = !found.is_empty() && in_string_literal(host, window, doc, pos).await;
|
||||
definition_targets(result, found, in_string)
|
||||
}
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
//! ⌘B on a Maven resource-filtering placeholder: `@property@` in a YAML or properties
|
||||
//! resource (Spring's `application.yml` / `application.properties`) jumps to the `<properties>` entry that defines it,
|
||||
//! in the nearest `pom.xml` above the file, up through the project root. Parent
|
||||
//! poms the nearest pom declares itself are followed from there; a parent outside
|
||||
//! that walk that no pom declares is not.
|
||||
|
||||
use super::doc::blocking;
|
||||
use crate::Host;
|
||||
use ide_build::maven;
|
||||
use ide_core::{DocId, Location, Pos};
|
||||
use std::path::Path;
|
||||
|
||||
/// The definition location of the placeholder under `pos` in `doc`, when `doc` is a
|
||||
/// YAML or properties file holding a `@token@` there and a pom above it defines that property.
|
||||
pub(crate) async fn definition(host: &Host, window: &str, doc: DocId, pos: Pos) -> Option<Location> {
|
||||
let project = host.project(window).ok()?;
|
||||
blocking(move || {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large || !matches!(snap.language.as_str(), "yaml" | "properties") {
|
||||
return Ok(None);
|
||||
}
|
||||
let path = project.documents.identity(doc)?.0;
|
||||
let Some((name, _token_at)) = placeholder_at(&snap.text, pos) else { return Ok(None) };
|
||||
Ok(pom_defining(&project.root, &path, &name))
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// The `@token@` enclosing `pos` on its line, with the token's range (UTF-16 columns).
|
||||
fn placeholder_at(text: &str, pos: Pos) -> Option<(String, ide_core::Range)> {
|
||||
let line = text.split_inclusive('\n').nth(pos.line as usize)?;
|
||||
let line = line.trim_end_matches(['\n', '\r']);
|
||||
let cursor = utf16_to_byte(line, pos.col)?;
|
||||
let mut opener: Option<usize> = None;
|
||||
for (i, b) in line.as_bytes().iter().enumerate() {
|
||||
if *b != b'@' {
|
||||
continue;
|
||||
}
|
||||
if let Some(start) = opener.replace(i) {
|
||||
let token = &line[start + 1..i];
|
||||
let valid =
|
||||
!token.is_empty() && token.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'));
|
||||
if valid && start <= cursor && cursor <= i {
|
||||
let col = |byte: usize| line[..byte].encode_utf16().count() as u32;
|
||||
return Some((
|
||||
token.to_owned(),
|
||||
ide_core::Range::new(Pos::new(pos.line, col(start)), Pos::new(pos.line, col(i + 1))),
|
||||
));
|
||||
}
|
||||
opener = None;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The nearest `pom.xml` above `from` (up to and including `root`) defining `name`.
|
||||
fn pom_defining(root: &Path, from: &Path, name: &str) -> Option<Location> {
|
||||
let mut dir = from.parent()?.to_path_buf();
|
||||
loop {
|
||||
let pom = dir.join("pom.xml");
|
||||
if pom.is_file()
|
||||
&& let Some(found) = maven::property_declaration(&pom, name, maven::default_local_repo())
|
||||
{
|
||||
return Some(Location::file(found.path, found.range));
|
||||
}
|
||||
if dir == root || !dir.starts_with(root) {
|
||||
return None;
|
||||
}
|
||||
dir = dir.parent()?.to_path_buf();
|
||||
}
|
||||
}
|
||||
|
||||
/// UTF-16 column → byte offset within one line.
|
||||
fn utf16_to_byte(line: &str, col: u32) -> Option<usize> {
|
||||
let col = col as usize;
|
||||
let mut units = 0usize;
|
||||
for (byte, c) in line.char_indices() {
|
||||
if units == col {
|
||||
return Some(byte);
|
||||
}
|
||||
units += c.len_utf16();
|
||||
if units > col {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
(units == col).then_some(line.len())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::Pos;
|
||||
|
||||
fn at(line: u32, col: u32) -> Pos {
|
||||
Pos::new(line, col)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_placeholder_under_the_cursor_and_its_range() {
|
||||
let text = "spring:\n profiles:\n active: @profileActive@\n";
|
||||
let (name, range) = placeholder_at(text, at(2, 20)).unwrap();
|
||||
assert_eq!(name, "profileActive");
|
||||
assert_eq!(range.start, at(2, 12));
|
||||
assert_eq!(range.end, at(2, 27));
|
||||
// The `@`s themselves and inside the token navigate; just past the token does not.
|
||||
for col in [12u32, 13, 26] {
|
||||
assert_eq!(placeholder_at(text, at(2, col)).unwrap().0, "profileActive");
|
||||
}
|
||||
// A second pair on the line and unrelated cursors stay unresolved.
|
||||
let multi = "a: @one@ @two@\n";
|
||||
assert_eq!(placeholder_at(multi, at(0, 4)).unwrap().0, "one");
|
||||
assert_eq!(placeholder_at(multi, at(0, 10)).unwrap().0, "two");
|
||||
assert!(placeholder_at(multi, at(0, 8)).is_none(), "between the pairs");
|
||||
assert!(placeholder_at(multi, at(0, 9)).is_some(), "the opening @ of the next pair");
|
||||
assert!(placeholder_at(multi, at(0, 14)).is_none(), "just past the last pair");
|
||||
assert!(placeholder_at("value: plain\n", at(0, 7)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_nearest_pom_wins_and_the_walk_stops_at_the_project_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
let deep = root.join("core/src/main/resources");
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
std::fs::write(
|
||||
root.join("pom.xml"),
|
||||
"<project>\n <properties>\n <parentName>parent</parentName>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::create_dir_all(root.join("core")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("core/pom.xml"),
|
||||
"<project>\n <properties>\n <name>module</name>\n </properties>\n</project>\n",
|
||||
)
|
||||
.unwrap();
|
||||
let from = deep.join("application.yml");
|
||||
// The module pom defines `name` first: its file wins, pointing at its `<name>` entry.
|
||||
let found = pom_defining(&root, &from, "name").unwrap();
|
||||
assert_eq!(found.path, root.join("core/pom.xml"));
|
||||
assert_eq!(found.range.start.line, 2);
|
||||
// A property only the parent defines resolves there; unknown ones resolve nowhere.
|
||||
let parent = pom_defining(&root, &from, "parentName").unwrap();
|
||||
assert_eq!(parent.path, root.join("pom.xml"));
|
||||
assert_eq!(parent.range.start.line, 2);
|
||||
assert!(pom_defining(&root, &from, "missing").is_none());
|
||||
// A file outside the project root has no pom walk.
|
||||
let outside = tmp.path().join("elsewhere/application.yml");
|
||||
std::fs::create_dir_all(tmp.path().join("elsewhere")).unwrap();
|
||||
assert!(pom_defining(&root, &outside, "name").is_none());
|
||||
}
|
||||
}
|
||||
@@ -15,14 +15,12 @@ pub mod deploy;
|
||||
pub mod doc;
|
||||
pub mod docker;
|
||||
pub mod env;
|
||||
pub mod flutter;
|
||||
pub mod fs;
|
||||
pub mod heap;
|
||||
pub mod history;
|
||||
pub mod java;
|
||||
pub mod jvm_icons;
|
||||
pub mod lsp;
|
||||
pub mod maven_placeholder;
|
||||
pub mod nav;
|
||||
pub mod notebook;
|
||||
pub mod project;
|
||||
@@ -86,14 +84,12 @@ ide_command::domains!(
|
||||
doc_commands: crate::ops::doc::commands,
|
||||
docker: crate::ops::docker,
|
||||
env: crate::ops::env,
|
||||
flutter: crate::ops::flutter,
|
||||
fs: crate::ops::fs,
|
||||
heap: crate::ops::heap,
|
||||
history: crate::ops::history,
|
||||
java: crate::ops::java,
|
||||
jvm_icons: crate::ops::jvm_icons,
|
||||
lsp: crate::ops::lsp,
|
||||
mcp: crate::mcp::service,
|
||||
mcp_reports: crate::mcp::reports,
|
||||
nav: crate::ops::nav,
|
||||
notebook: crate::ops::notebook,
|
||||
@@ -101,7 +97,6 @@ ide_command::domains!(
|
||||
plugins_commit: crate::plugins::commit,
|
||||
plugins_index_ops: crate::plugins::index_ops,
|
||||
plugins_run_targets: crate::plugins::run_targets,
|
||||
plugins_search: crate::plugins::search,
|
||||
plugins_views: crate::plugins::views,
|
||||
project: crate::ops::project,
|
||||
refactor: crate::ops::refactor,
|
||||
|
||||
@@ -68,31 +68,6 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
|
||||
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
|
||||
}
|
||||
|
||||
/// The files of a custom scope (`file:src//*.ts`), for the Project view's scope panes.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ScopeFiles {
|
||||
pub paths: Vec<IpcPath>,
|
||||
/// More files than `limit` matched; `paths` holds the first ones.
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
#[command(trust = always)]
|
||||
pub async fn scope_files(host: &Host, window: &str, pattern: String, limit: u32) -> IdeResult<ScopeFiles> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
let mask = ide_search::FileMask::new(&[], &project.search_excludes())?;
|
||||
let scope = ide_search::SearchScope::Pattern { pattern };
|
||||
let mut files =
|
||||
ide_search::scope_files(&project.root, &scope, &mask, None, &ide_core::CancellationToken::new())?;
|
||||
files.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
|
||||
let truncated = files.len() > limit as usize;
|
||||
files.truncate(limit as usize);
|
||||
Ok(ScopeFiles { paths: files.into_iter().map(|f| f.path.into()).collect(), truncated })
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Folders holding indexed files, for `@` references.
|
||||
#[command(trust = always)]
|
||||
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
@@ -400,7 +375,6 @@ ide_command::domain!(
|
||||
path_completions,
|
||||
recent_files,
|
||||
remove_recent,
|
||||
scope_files,
|
||||
web_goto,
|
||||
web_unresolved_references,
|
||||
);
|
||||
@@ -80,13 +80,6 @@ pub fn settings_get(host: &Host, window: &str) -> Settings {
|
||||
})
|
||||
}
|
||||
|
||||
/// Defaults plus the global layer, without any project's values: what new
|
||||
/// projects (and projects without their own value) get.
|
||||
#[command(trust = always)]
|
||||
pub fn settings_get_global(host: &Host) -> Settings {
|
||||
host.with_proxy_password(host.global_settings.effective())
|
||||
}
|
||||
|
||||
/// The removed built-in theme id a settings file of this window still names, if any:
|
||||
/// `settings_get` reports the built-in that stands in for it, so the notice about
|
||||
/// a theme that moved to a plugin can address the installs it concerns.
|
||||
@@ -103,16 +96,13 @@ pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
|
||||
/// re-reads its effective settings.
|
||||
#[command(trust = always, desktop_body = sync)]
|
||||
pub fn settings_set(
|
||||
host: &Arc<Host>,
|
||||
host: &Host,
|
||||
window: &str,
|
||||
scope: SettingsScope,
|
||||
key: String,
|
||||
value: String,
|
||||
) -> IdeResult<Settings> {
|
||||
let applied = set_settings(host, window, scope, &key, &value)?;
|
||||
if key == "mcpServer" || key.starts_with("mcpServer.") {
|
||||
host.mcp.apply(host);
|
||||
}
|
||||
let sink = host.window_sink(window);
|
||||
sink.emit(IdeEvent::SettingsChanged { key });
|
||||
if let Some(root) = applied.roots_changed {
|
||||
@@ -312,15 +302,6 @@ pub fn set_settings(
|
||||
}
|
||||
});
|
||||
}
|
||||
// Directory Mappings change which repositories the project has.
|
||||
if key == "vcs" || key == "vcs.mappings" || key.starts_with("vcs.mappings.") {
|
||||
let affected = affected();
|
||||
host.runtime.spawn_blocking(move || {
|
||||
for project in affected {
|
||||
project.refresh_repositories();
|
||||
}
|
||||
});
|
||||
}
|
||||
if key == "ssh" || key.starts_with("ssh.") {
|
||||
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
|
||||
}
|
||||
@@ -396,7 +377,6 @@ ide_command::domain!(
|
||||
project_trust_set,
|
||||
project_trust_status,
|
||||
settings_get,
|
||||
settings_get_global,
|
||||
settings_removed_theme,
|
||||
settings_set,
|
||||
);
|
||||
@@ -34,9 +34,9 @@ pub struct ProjectInterpreter {
|
||||
}
|
||||
|
||||
/// Installed interpreters / toolchains of `kind`; project-local ones first.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window).ok();
|
||||
if kind == SdkKind::Jdk {
|
||||
host.apply_added_jdks();
|
||||
@@ -63,10 +63,10 @@ pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<V
|
||||
}
|
||||
|
||||
/// The Python interpreters of the recently opened projects, each with its project.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeResult<Vec<ProjectInterpreter>> {
|
||||
// Newest first. The open project is skipped: `sdk_detect` lists its own.
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let current = host.project(window).ok().map(|p| p.root.clone());
|
||||
let config = host.config_dir.clone();
|
||||
// Probing runs the project's interpreter (and its settings may name any program): only
|
||||
@@ -111,9 +111,9 @@ pub async fn sdk_python_project_interpreters(host: &Host, window: &str) -> IdeRe
|
||||
}
|
||||
|
||||
/// An existing Python executable or virtualenv folder as an SDK; `None` if Python cannot run.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<Sdk>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
tokio::task::spawn_blocking(move || Ok(ide_sdk::python_interpreter_sdk(&path, root.as_deref())))
|
||||
.await
|
||||
@@ -320,7 +320,7 @@ pub async fn sdk_locate_tools(
|
||||
}
|
||||
|
||||
/// Creates a Python environment with `tool` (`venv` / `uv` / `poetry`); output streams through `on_output`.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_create_venv(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -330,7 +330,7 @@ pub async fn sdk_python_create_venv(
|
||||
request: RequestId,
|
||||
on_output: Channel<String>,
|
||||
) -> IdeResult<Sdk> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
ide_sdk::python::create_venv(tool, &base, &location, &cancel, &|line| {
|
||||
@@ -343,14 +343,14 @@ pub async fn sdk_python_create_venv(
|
||||
result?
|
||||
}
|
||||
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_packages(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
python: PathBuf,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PythonPackage>> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result =
|
||||
tokio::task::spawn_blocking(move || ide_sdk::python::list_packages(&python, &cancel)).await.map_err(join_err);
|
||||
@@ -360,7 +360,7 @@ pub async fn sdk_python_packages(
|
||||
|
||||
/// Installs (`uninstall = false`) or removes a package; output streams through `on_output`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn sdk_python_pip(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -371,7 +371,7 @@ pub async fn sdk_python_pip(
|
||||
request: RequestId,
|
||||
on_output: Channel<String>,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let project_root = host.project(window).ok().map(|p| p.root.clone());
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
|
||||
@@ -34,10 +34,8 @@ pub async fn search_start(
|
||||
) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
// Excluded roots (Project Structure marks and detected `target`, `node_modules`, …) and
|
||||
// ignored names are not searched, unless the query asks for them.
|
||||
if !query.include_excluded {
|
||||
query.exclude.extend(project.search_excludes());
|
||||
}
|
||||
// ignored names are never searched.
|
||||
query.exclude.extend(project.search_excludes());
|
||||
let cancel = host.begin_request(request);
|
||||
let events = on_event.clone();
|
||||
let syntax = host.syntax();
|
||||
@@ -82,15 +80,10 @@ pub(crate) fn search_project(
|
||||
query.scope,
|
||||
ide_search::SearchScope::Directory { .. } | ide_search::SearchScope::Files { .. }
|
||||
));
|
||||
let content_roots: Vec<std::path::PathBuf> = match query.scope {
|
||||
let content_roots = match query.scope {
|
||||
ide_search::SearchScope::Project
|
||||
| ide_search::SearchScope::FileSet { .. }
|
||||
| ide_search::SearchScope::Pattern { .. } => project
|
||||
.content_roots()
|
||||
.into_iter()
|
||||
// Kept out of the root's walk only by its ignore rules, which this search does not apply.
|
||||
.filter(|r| !(query.include_excluded && include_root && r.starts_with(root)))
|
||||
.collect(),
|
||||
| ide_search::SearchScope::Pattern { .. } => project.content_roots(),
|
||||
_ => within.into_iter().collect(),
|
||||
};
|
||||
let filter = |rel: &str| match set {
|
||||
@@ -151,7 +144,7 @@ pub(crate) fn search_project(
|
||||
/// Project-relative `masks` (each a comma-separated list) for a search from the content root
|
||||
/// shown as `prefix`: paths below it lose the prefix, other paths can match nothing there and
|
||||
/// are dropped, names and `**/` patterns (`*.rs`, `**/build/**`) stay as they are.
|
||||
pub(crate) fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
|
||||
fn rebase_masks(masks: &[String], prefix: &str) -> Vec<String> {
|
||||
let prefix = format!("{}/", prefix.trim_end_matches('/'));
|
||||
masks
|
||||
.iter()
|
||||
|
||||
@@ -15,9 +15,6 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
Some(doc) => (doc, false),
|
||||
None => (docs.open(path)?.id, true),
|
||||
};
|
||||
// A buffer without unsaved changes (open only for the search preview, or a clean
|
||||
// tab) is saved like a closed file; one the user is editing is left unsaved.
|
||||
let save = transient || !docs.is_dirty(doc)?;
|
||||
let result = (|| {
|
||||
// Recompute if the user typed between reading the text and applying.
|
||||
for _ in 0..3 {
|
||||
@@ -30,7 +27,7 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
continue;
|
||||
}
|
||||
docs.apply_edits(doc, &edits)?;
|
||||
if save {
|
||||
if transient {
|
||||
docs.save(doc)?;
|
||||
}
|
||||
return Ok(edits.len() as u32);
|
||||
@@ -49,8 +46,8 @@ impl ReplaceHost for DocumentsHost<'_> {
|
||||
///
|
||||
/// Edits go through the document layer as one patch per file, so open editors
|
||||
/// update live and undo the whole file's replacements in one step. Unsaved
|
||||
/// editor buffers are replaced in place and left unsaved; other open documents
|
||||
/// are saved, and files that were not open are opened transiently, saved and closed.
|
||||
/// editor buffers are replaced in place and left unsaved; files that were not
|
||||
/// open are opened transiently, saved and closed.
|
||||
///
|
||||
/// With `all_in_scope` (Replace All after the search hit its match limit) the
|
||||
/// scope is searched again without the limit and every match in it is replaced,
|
||||
|
||||
@@ -11,29 +11,22 @@ use std::path::PathBuf;
|
||||
|
||||
/// The installer, reporting the executables chosen in the window's settings.
|
||||
fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
|
||||
host.require_trust_if_project(window)?;
|
||||
host.require_trust(window)?;
|
||||
let data = host.local_data_dir.clone();
|
||||
let (settings, root) = match host.project(window) {
|
||||
Ok(project) => (project.settings.effective(), project.root.clone()),
|
||||
Err(_) => (host.global_settings.effective(), Default::default()),
|
||||
};
|
||||
let mut custom: std::collections::BTreeMap<_, _> = settings
|
||||
let custom = settings
|
||||
.tools
|
||||
.iter()
|
||||
.filter_map(|(command, t)| Some((command.clone(), ide_sdk::apply::setting_path(&root, &t.path)?)))
|
||||
.collect();
|
||||
let langs = host.languages.all();
|
||||
custom.extend(ide_sdk::apply::server_command_paths(
|
||||
langs.iter().flat_map(|l| &l.language_servers),
|
||||
&root,
|
||||
&settings,
|
||||
));
|
||||
// Godot is usually an app bundle / Flatpak outside the search path.
|
||||
let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));
|
||||
let runtime = ide_sdk::apply::tool_install_environment(&root, &settings);
|
||||
let work_dir = (!root.as_os_str().is_empty()).then_some(root);
|
||||
Ok(Tools::new(&data)
|
||||
.with_downloads(settings.tool_downloads.clone())
|
||||
.with_runtime(runtime.commands, runtime.env)
|
||||
.with_custom_paths(custom)
|
||||
.with_found_paths(found.into_iter().collect())
|
||||
@@ -63,7 +56,7 @@ fn reconfigure_servers(host: &Host) {
|
||||
}
|
||||
|
||||
/// Status of every known language server / debug adapter and the languages using it.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
|
||||
let tools = tools(host, window)?;
|
||||
let langs = languages(host, window);
|
||||
@@ -72,7 +65,7 @@ pub async fn tools_list(host: &Host, window: &str) -> IdeResult<Vec<ToolInfo>> {
|
||||
|
||||
/// Installs (or reinstalls) a tool into `<app-data>/tools`, streaming output through
|
||||
/// `on_event`. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_install(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -100,7 +93,7 @@ pub async fn tools_install(
|
||||
|
||||
/// Newer versions of the tools the IDE installed (release downloads and npm packages).
|
||||
/// Cancel with `cancel_request(request)`.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> IdeResult<Vec<ToolUpdate>> {
|
||||
let tools = tools(host, window)?;
|
||||
let cancel = host.begin_request(request);
|
||||
@@ -110,7 +103,7 @@ pub async fn tools_updates(host: &Host, window: &str, request: RequestId) -> Ide
|
||||
}
|
||||
|
||||
/// Removes a tool the IDE installed.
|
||||
#[command(trust = outside_restricted)]
|
||||
#[command(trust = trusted)]
|
||||
pub async fn tools_uninstall(host: &Host, window: &str, name: String) -> IdeResult<ToolInfo> {
|
||||
let tools = tools(host, window)?;
|
||||
let langs = languages(host, window);
|
||||
|
||||
@@ -18,7 +18,6 @@ pub async fn vcs_status(host: &Host, window: &str) -> IdeResult<Vec<FileStatus>>
|
||||
}
|
||||
for r in repos.all() {
|
||||
r.set_ignored_names(settings.ignored_names());
|
||||
r.set_cli_status(settings.vcs.git.cli_status);
|
||||
}
|
||||
repos.status()
|
||||
})
|
||||
@@ -41,7 +40,6 @@ pub async fn vcs_status_paths(host: &Host, window: &str, paths: Vec<std::path::P
|
||||
}
|
||||
for r in repos.all() {
|
||||
r.set_ignored_names(settings.ignored_names());
|
||||
r.set_cli_status(settings.vcs.git.cli_status);
|
||||
}
|
||||
repos.status_paths(&paths)
|
||||
})
|
||||
|
||||
@@ -338,13 +338,6 @@ fn keep_private(root: &Path) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Directory Mappings: the repository roots detection finds, before any are excluded or added.
|
||||
#[command(trust = always)]
|
||||
pub async fn vcs_detected_roots(host: &Host, window: &str) -> IdeResult<Vec<PathBuf>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.detected_repository_roots()).await
|
||||
}
|
||||
|
||||
/// The project's repositories, the primary one first.
|
||||
#[command(trust = always)]
|
||||
pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
|
||||
@@ -1068,22 +1061,6 @@ pub async fn vcs_config_get(
|
||||
blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
|
||||
}
|
||||
|
||||
/// Git User Name Is Not Defined: sets `user.name` / `user.email` for commits in the
|
||||
/// repository, or globally.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn vcs_set_user_identity(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
repo: Option<PathBuf>,
|
||||
name: String,
|
||||
email: String,
|
||||
global: bool,
|
||||
) -> IdeResult<()> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || project.with_repo_at(repo.as_deref(), |r| r.set_user_identity(&name, &email, global))).await
|
||||
}
|
||||
|
||||
/// Local history operation that may take a while (hooks, large checkouts); git's
|
||||
/// output streams through `on_output`. Cancellable.
|
||||
#[command(trust = trusted)]
|
||||
@@ -1592,7 +1569,6 @@ ide_command::domain!(
|
||||
vcs_compare_paths,
|
||||
vcs_compare_scope,
|
||||
vcs_config_get,
|
||||
vcs_set_user_identity,
|
||||
vcs_conflict_versions,
|
||||
vcs_create_branch,
|
||||
vcs_create_patch,
|
||||
@@ -1640,7 +1616,6 @@ ide_command::domain!(
|
||||
vcs_revision_files,
|
||||
vcs_reword,
|
||||
vcs_roots,
|
||||
vcs_detected_roots,
|
||||
vcs_shelf_delete,
|
||||
vcs_shelf_diff,
|
||||
vcs_shelf_import,
|
||||
|
||||
@@ -47,19 +47,12 @@ pub async fn serves_page(url: &str) -> bool {
|
||||
response.status().is_success() && html
|
||||
}
|
||||
|
||||
/// The built-in server's URL for `path` (started on first use). A file whose language is
|
||||
/// HTML (Settings › File Types can make it so) is served as a page, whatever its extension.
|
||||
/// The built-in server's URL for `path` (started on first use).
|
||||
#[command(trust = always)]
|
||||
pub async fn web_url(host: &Host, window: &str, path: IpcPath) -> IdeResult<String> {
|
||||
// Under the window's project when it holds the file.
|
||||
let project = host.project(window).ok();
|
||||
let root = project.as_ref().map(|p| p.root.as_path());
|
||||
let languages = project.as_ref().map_or(&host.languages, |p| &p.languages);
|
||||
if matches!(languages.detect(&path, None).as_str(), "html" | "django-html") {
|
||||
host.web.page_url_for(root, &path).await
|
||||
} else {
|
||||
host.web.url_for(root, &path).await
|
||||
}
|
||||
let root = host.project(window).ok().map(|p| p.root.clone());
|
||||
host.web.url_for(root.as_deref(), &path).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -568,8 +568,6 @@ pub(super) struct Shared {
|
||||
/// (plugin, item id) → item, for windows opened later.
|
||||
output: Mutex<BTreeMap<(String, String), String>>,
|
||||
decorations: Mutex<BTreeMap<String, Vec<super::DecorationSet>>>,
|
||||
/// plugin → its console highlight rules, in order.
|
||||
console_rules: Mutex<BTreeMap<String, Vec<ide_plugin::ConsoleRule>>>,
|
||||
status: Mutex<BTreeMap<(String, String), StatusItem>>,
|
||||
setting_snapshots: Mutex<SettingSnapshots>,
|
||||
window_status: Mutex<BTreeMap<(String, String, String), StatusItem>>,
|
||||
@@ -650,7 +648,6 @@ impl Shared {
|
||||
status: Mutex::default(),
|
||||
output: Mutex::default(),
|
||||
decorations: Mutex::default(),
|
||||
console_rules: Mutex::default(),
|
||||
window_status: Mutex::default(),
|
||||
setting_snapshots: Mutex::default(),
|
||||
contexts: Mutex::default(),
|
||||
@@ -877,9 +874,6 @@ impl Shared {
|
||||
if self.decorations.lock().remove(plugin).is_some() {
|
||||
self.sink.emit(None, PluginEvent::DecorationsChanged { plugin_id: plugin.into(), sets: Vec::new() });
|
||||
}
|
||||
if self.console_rules.lock().remove(plugin).is_some() {
|
||||
self.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: plugin.into(), rules: Vec::new() });
|
||||
}
|
||||
self.withdraw_prompts(plugin);
|
||||
self.net_prompts.lock().remove(plugin);
|
||||
self.session_net_hosts.lock().remove(plugin);
|
||||
@@ -1712,18 +1706,6 @@ impl HostApi for PluginApi {
|
||||
fn file_icon_decorations(&self, set: &str, items: Vec<(PathBuf, String)>) -> Result<(), HostError> {
|
||||
self.set_file_icon_decorations(set, items)
|
||||
}
|
||||
fn console_rules(&self, rules: Vec<ide_plugin::ConsoleRule>) -> Result<(), HostError> {
|
||||
let rules = super::console_rules::normalize(rules).map_err(HostError::Invalid)?;
|
||||
let mut all = self.shared.console_rules.lock();
|
||||
if rules.is_empty() {
|
||||
all.remove(self.id());
|
||||
} else {
|
||||
all.insert(self.id().into(), rules.clone());
|
||||
}
|
||||
// Emitted under the lock so replacements cannot arrive out of order.
|
||||
self.shared.sink.emit(None, PluginEvent::ConsoleRulesChanged { plugin_id: self.id().into(), rules });
|
||||
Ok(())
|
||||
}
|
||||
fn vcs_log(
|
||||
&self,
|
||||
root: &Path,
|
||||
@@ -3294,7 +3276,6 @@ impl PluginWorkspace for HostWorkspace {
|
||||
scope: ide_search::SearchScope::Project,
|
||||
max_matches: limit.min(10_000).saturating_add(1),
|
||||
context: Default::default(),
|
||||
include_excluded: false,
|
||||
};
|
||||
query.exclude.extend(project.search_excludes());
|
||||
let files = Mutex::new(Vec::new());
|
||||
@@ -4460,9 +4441,6 @@ impl Shared {
|
||||
pub(super) fn decoration_sets(&self) -> BTreeMap<String, Vec<super::DecorationSet>> {
|
||||
self.decorations.lock().clone()
|
||||
}
|
||||
pub(super) fn console_rules(&self) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
self.console_rules.lock().clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -4634,34 +4612,6 @@ mod workbench_tests {
|
||||
assert!(api.shared.decoration_sets().is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn console_rules_replace_keep_the_last_valid_list_and_go_with_the_plugin() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let api = api(dir.path(), false, None);
|
||||
let rule = |pattern: &str| ide_plugin::ConsoleRule {
|
||||
pattern: pattern.into(),
|
||||
ignore_case: false,
|
||||
foreground: Some("bright-yellow".into()),
|
||||
background: Some("navy".into()),
|
||||
styles: vec!["bold".into()],
|
||||
whole_line: true,
|
||||
enabled: true,
|
||||
};
|
||||
// No capability, and no trusted project, is needed: the rules read nothing.
|
||||
api.console_rules(vec![rule(r"\[AUDIT\]"), rule(r"JOB-\d+")]).unwrap();
|
||||
let rules = &api.shared.console_rules()["test"];
|
||||
assert_eq!(rules.len(), 2);
|
||||
assert_eq!((rules[0].foreground.as_deref(), rules[0].background.as_deref()), (Some("bright-yellow"), None));
|
||||
assert!(matches!(api.console_rules(vec![rule("(a+)+b")]), Err(HostError::Invalid(_))));
|
||||
assert_eq!(api.shared.console_rules()["test"].len(), 2);
|
||||
api.console_rules(vec![rule("x")]).unwrap();
|
||||
assert_eq!(api.shared.console_rules()["test"].len(), 1);
|
||||
api.console_rules(Vec::new()).unwrap();
|
||||
assert!(api.shared.console_rules().is_empty());
|
||||
api.console_rules(vec![rule("x")]).unwrap();
|
||||
api.shared.clear_plugin("test", true);
|
||||
assert!(api.shared.console_rules().is_empty());
|
||||
}
|
||||
#[test]
|
||||
fn decoration_styles_keep_the_severity_palette_the_editor_renders() {
|
||||
// Inspection Lens colours typos and weak warnings with their own styles; the
|
||||
// host must keep them, not silently drop them the way an unknown style is dropped.
|
||||
|
||||
@@ -184,12 +184,6 @@ pub fn plugin_decoration_sets(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec
|
||||
plugins.decoration_sets()
|
||||
}
|
||||
|
||||
/// Every plugin's console highlight rules (later changes arrive as `consoleRulesChanged`).
|
||||
#[command(trust = trusted)]
|
||||
pub fn plugin_console_rules(plugins: &Arc<PluginHost>) -> BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
plugins.console_rules()
|
||||
}
|
||||
|
||||
/// Reports exactly one completion from the operation's launching window.
|
||||
#[command(trust = trusted)]
|
||||
pub fn plugin_finish_operation(
|
||||
@@ -302,7 +296,6 @@ ide_command::domain!(
|
||||
plugin_answer_prompt,
|
||||
plugin_cancel_task,
|
||||
plugin_choose_program,
|
||||
plugin_console_rules,
|
||||
plugin_content_tab_action,
|
||||
plugin_context_keys,
|
||||
plugin_debug_attach_target,
|
||||
|
||||
@@ -1,325 +0,0 @@
|
||||
//! Console highlight rules (API 1.12, `ui.set-console-rules`): validated here,
|
||||
//! matched by the windows with JavaScript's backtracking `RegExp`. A rule is
|
||||
//! refused unless its worst case on a line of [`LINE_LEN`] characters stays
|
||||
//! within [`MAX_STEPS`] backtracking steps, estimated from its structure.
|
||||
|
||||
use ide_plugin::ConsoleRule;
|
||||
use regex_syntax::hir::{Class, ClassUnicode, ClassUnicodeRange, Hir, HirKind, Look};
|
||||
|
||||
pub(crate) const MAX_RULES: usize = 100;
|
||||
/// The characters of a line the windows match rules against (`src/ui/consoleRules.ts`).
|
||||
const LINE_LEN: u64 = 2000;
|
||||
/// About 4 · 2000², a few milliseconds of `RegExp` work for one line.
|
||||
const MAX_STEPS: u64 = 4 * LINE_LEN * LINE_LEN;
|
||||
|
||||
const COLORS: &[&str] = &["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
|
||||
const STYLES: &[&str] = &["bold", "italic", "underline", "strikethrough", "dim"];
|
||||
|
||||
/// Validates every rule and drops colours and styles this host doesn't know.
|
||||
pub(crate) fn normalize(rules: Vec<ConsoleRule>) -> Result<Vec<ConsoleRule>, String> {
|
||||
if rules.len() > MAX_RULES {
|
||||
return Err(format!("at most {MAX_RULES} console rules"));
|
||||
}
|
||||
rules
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(i, rule)| {
|
||||
validate_pattern(&rule.pattern, rule.ignore_case).map_err(|e| format!("console rule {i}: {e}"))?;
|
||||
let mut styles: Vec<String> = Vec::new();
|
||||
for style in rule.styles {
|
||||
if STYLES.contains(&style.as_str()) && !styles.contains(&style) {
|
||||
styles.push(style);
|
||||
}
|
||||
}
|
||||
Ok(ConsoleRule {
|
||||
foreground: rule.foreground.filter(|c| known_color(c)),
|
||||
background: rule.background.filter(|c| known_color(c)),
|
||||
styles,
|
||||
..rule
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn known_color(name: &str) -> bool {
|
||||
COLORS.contains(&name.strip_prefix("bright-").unwrap_or(name))
|
||||
}
|
||||
|
||||
fn validate_pattern(pattern: &str, ignore_case: bool) -> Result<(), String> {
|
||||
if pattern.is_empty() {
|
||||
return Err("empty pattern".into());
|
||||
}
|
||||
if pattern.len() > super::icon_patterns::MAX_PATTERN_LEN {
|
||||
return Err(format!("pattern {pattern:?} is too long (max {})", super::icon_patterns::MAX_PATTERN_LEN));
|
||||
}
|
||||
if let Some(construct) = super::icon_patterns::unsupported_construct(pattern) {
|
||||
return Err(format!("pattern {pattern:?}: {construct} is not supported"));
|
||||
}
|
||||
let parse = |p: &str| {
|
||||
regex_syntax::ParserBuilder::new()
|
||||
.case_insensitive(ignore_case)
|
||||
.build()
|
||||
.parse(p)
|
||||
.map_err(|e| format!("invalid pattern {pattern:?}: {e}"))
|
||||
};
|
||||
parse(pattern)?;
|
||||
let hir = parse(&javascript_classes(pattern))?;
|
||||
let anchored = starts_anchored(&hir);
|
||||
let cost = cost(&hir, &ClassUnicode::empty(), true)
|
||||
.map_err(|why| format!("pattern {pattern:?}: {why} is not supported"))?;
|
||||
let starts = if anchored { 1 } else { LINE_LEN };
|
||||
if cost.work.saturating_mul(starts) > MAX_STEPS {
|
||||
return Err(format!(
|
||||
"pattern {pattern:?} could take too long on a long line: avoid two repetitions that can match the same text (`.*a.*b`, `\\w+\\w+`); a class such as `[^)]*` often helps"
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn starts_anchored(hir: &Hir) -> bool {
|
||||
match hir.kind() {
|
||||
HirKind::Look(Look::Start) => true,
|
||||
HirKind::Capture(c) => starts_anchored(&c.sub),
|
||||
HirKind::Concat(items) => items.first().is_some_and(starts_anchored),
|
||||
HirKind::Alternation(items) => items.iter().all(starts_anchored),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// From one start: `ways` the expression can end (each a backtracking point for
|
||||
/// what follows) and the `work` of trying them all when what follows fails.
|
||||
/// `scan`: the work is one pass over a run of characters.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Cost {
|
||||
ways: u64,
|
||||
work: u64,
|
||||
scan: bool,
|
||||
}
|
||||
|
||||
const ONE: Cost = Cost { ways: 1, work: 1, scan: false };
|
||||
|
||||
/// `follow`: the characters what comes after `hir` can start with (empty when
|
||||
/// only assertions follow). `last`: nothing follows, so the first way to end is the match.
|
||||
fn cost(hir: &Hir, follow: &ClassUnicode, last: bool) -> Result<Cost, &'static str> {
|
||||
match hir.kind() {
|
||||
HirKind::Empty | HirKind::Literal(_) | HirKind::Class(_) | HirKind::Look(_) => Ok(ONE),
|
||||
HirKind::Capture(c) => cost(&c.sub, follow, last),
|
||||
HirKind::Concat(items) => {
|
||||
let mut total = Cost { ways: 1, work: 0, scan: false };
|
||||
let mut fixed = false;
|
||||
let mut scanned = None;
|
||||
for (i, item) in items.iter().enumerate() {
|
||||
let rest = &items[i + 1..];
|
||||
// Nothing after this can fail: the first way to end is the match.
|
||||
if last && rest.is_empty() && nullable(item) {
|
||||
total.work = total.work.saturating_add(total.ways);
|
||||
break;
|
||||
}
|
||||
let next = first_of_seq(rest, follow);
|
||||
let c = cost(item, &next, last && rest.is_empty())?;
|
||||
// In a run of single characters (`[Ee][Rr]…`) only the first one is tried each way,
|
||||
// and runs of one way cover different parts of the line: one pass in all.
|
||||
let single = c.ways == 1 && c.work == 1;
|
||||
let rescan = c.scan && scanned == Some(total.ways);
|
||||
if !(single && fixed) && !rescan {
|
||||
total.work = total.work.saturating_add(total.ways.saturating_mul(c.work));
|
||||
}
|
||||
fixed = single;
|
||||
if c.scan {
|
||||
scanned = Some(total.ways);
|
||||
}
|
||||
total.ways = total.ways.saturating_mul(c.ways);
|
||||
}
|
||||
Ok(Cost { ways: total.ways, work: total.work.max(1), scan: false })
|
||||
}
|
||||
HirKind::Alternation(items) => items.iter().try_fold(Cost { ways: 0, work: 0, scan: false }, |acc, h| {
|
||||
let c = cost(h, follow, last)?;
|
||||
Ok(Cost { ways: acc.ways.saturating_add(c.ways), work: acc.work.saturating_add(c.work), scan: false })
|
||||
}),
|
||||
HirKind::Repetition(r) => match r.max {
|
||||
None if matches!(r.sub.kind(), HirKind::Literal(_) | HirKind::Class(_)) => {
|
||||
// A run that what follows can't start inside ends in one place.
|
||||
let ways = if overlaps(&first(&r.sub), follow) { LINE_LEN } else { 1 };
|
||||
Ok(Cost { ways, work: LINE_LEN, scan: true })
|
||||
}
|
||||
None => Err("a repeated group (`(…)*`, `(…)+`)"),
|
||||
Some(max) => {
|
||||
// Each copy may end in `c.ways` places, and the count itself may vary.
|
||||
let c = cost(&r.sub, &union(&first(&r.sub), follow), false)?;
|
||||
let ways = c.ways.saturating_pow(max).saturating_mul(u64::from(max - r.min) + 1);
|
||||
Ok(Cost { ways, work: ways.saturating_mul(c.work).saturating_add(u64::from(max)), scan: false })
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn overlaps(a: &ClassUnicode, b: &ClassUnicode) -> bool {
|
||||
let mut both = a.clone();
|
||||
both.intersect(b);
|
||||
!both.ranges().is_empty()
|
||||
}
|
||||
|
||||
/// `pattern` with JavaScript's ASCII-only `\w` and `\d` (Rust's are Unicode), so that
|
||||
/// `\W` and `\D` include letters such as `é` as they do where the rules run.
|
||||
fn javascript_classes(pattern: &str) -> String {
|
||||
let mut out = String::with_capacity(pattern.len());
|
||||
let mut chars = pattern.chars();
|
||||
while let Some(c) = chars.next() {
|
||||
if c != '\\' {
|
||||
out.push(c);
|
||||
continue;
|
||||
}
|
||||
match chars.next() {
|
||||
Some('w') => out.push_str("[0-9A-Za-z_]"),
|
||||
Some('W') => out.push_str("[^0-9A-Za-z_]"),
|
||||
Some('d') => out.push_str("[0-9]"),
|
||||
Some('D') => out.push_str("[^0-9]"),
|
||||
Some(next) => {
|
||||
out.push('\\');
|
||||
out.push(next);
|
||||
}
|
||||
None => out.push('\\'),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn nullable(hir: &Hir) -> bool {
|
||||
hir.properties().minimum_len() == Some(0)
|
||||
}
|
||||
|
||||
/// The characters `hir` can start with (everything, for a byte class).
|
||||
fn first(hir: &Hir) -> ClassUnicode {
|
||||
match hir.kind() {
|
||||
HirKind::Empty | HirKind::Look(_) => ClassUnicode::empty(),
|
||||
HirKind::Literal(lit) => match std::str::from_utf8(&lit.0).ok().and_then(|s| s.chars().next()) {
|
||||
Some(c) => ClassUnicode::new([ClassUnicodeRange::new(c, c)]),
|
||||
None => any(),
|
||||
},
|
||||
HirKind::Class(Class::Unicode(class)) => class.clone(),
|
||||
HirKind::Class(Class::Bytes(_)) => any(),
|
||||
HirKind::Capture(c) => first(&c.sub),
|
||||
HirKind::Repetition(r) => first(&r.sub),
|
||||
HirKind::Concat(items) => first_of_seq(items, &ClassUnicode::empty()),
|
||||
HirKind::Alternation(items) => items.iter().fold(ClassUnicode::empty(), |acc, h| union(&acc, &first(h))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The characters a sequence can start with, then `follow` if it may match nothing.
|
||||
fn first_of_seq(items: &[Hir], follow: &ClassUnicode) -> ClassUnicode {
|
||||
let mut set = ClassUnicode::empty();
|
||||
for item in items {
|
||||
set = union(&set, &first(item));
|
||||
if !nullable(item) {
|
||||
return set;
|
||||
}
|
||||
}
|
||||
union(&set, follow)
|
||||
}
|
||||
|
||||
fn union(a: &ClassUnicode, b: &ClassUnicode) -> ClassUnicode {
|
||||
let mut out = a.clone();
|
||||
out.union(b);
|
||||
out
|
||||
}
|
||||
|
||||
fn any() -> ClassUnicode {
|
||||
ClassUnicode::new([ClassUnicodeRange::new('\0', char::MAX)])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn rule(pattern: &str) -> ConsoleRule {
|
||||
ConsoleRule {
|
||||
pattern: pattern.into(),
|
||||
ignore_case: false,
|
||||
foreground: Some("red".into()),
|
||||
background: None,
|
||||
styles: Vec::new(),
|
||||
whole_line: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn err(pattern: &str) -> String {
|
||||
validate_pattern(pattern, false).unwrap_err()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_typical_log_rules() {
|
||||
for pattern in [
|
||||
r"\[AUDIT\]",
|
||||
r"\[(AUDIT|METRIC|TASK-FAIL)\]",
|
||||
r"JOB-\d+",
|
||||
r"Exception in thread .*",
|
||||
r".*ERROR.*",
|
||||
r"took \d+(\.\d+)?ms",
|
||||
r"\d+\.\d+\.\d+\.\d+",
|
||||
r"\w+@\w+\.com",
|
||||
r"user=\S+\s+id=\d+",
|
||||
r#"^\s*at [^(]*\([^)]*\)$"#,
|
||||
r"^\[service-a\].*",
|
||||
r"SELECT .* FROM",
|
||||
r"\b(GET|POST|PUT|DELETE) /\S*",
|
||||
r"\d+(\.\d+){0,3}",
|
||||
r"\w+(-\w+){0,4}",
|
||||
r"(ERROR|WARN)\b.*$",
|
||||
] {
|
||||
assert!(validate_pattern(pattern, false).is_ok(), "{pattern}: {:?}", validate_pattern(pattern, false));
|
||||
assert!(validate_pattern(pattern, true).is_ok(), "{pattern} (ignore case)");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_patterns_that_backtrack_for_too_long() {
|
||||
// Each takes seconds or more on a 2000-character line in V8.
|
||||
assert!(err(r"(a+)+$").contains("repeated group"));
|
||||
assert!(err(r"^(a|aa)+b$").contains("repeated group"));
|
||||
assert!(err(r"a*a*a*b").contains("too long"));
|
||||
assert!(err(r".*a.*b").contains("too long"));
|
||||
assert!(err(r"\w+\w+!").contains("too long"));
|
||||
assert!(err(r"^(a?){30}a{30}$").contains("too long"));
|
||||
// A group before `$` or `\b` is not the end of the pattern: those can still fail.
|
||||
assert!(err(r"(x(a+)*)$").contains("repeated group"));
|
||||
assert!(err(r"(?:foo|x(a+)*)\b").contains("repeated group"));
|
||||
assert!(err(r"^(x\w*\w*\w*)$").contains("too long"));
|
||||
// JavaScript's `\W` matches `é` and `\D` matches `٣`, Rust's don't.
|
||||
assert!(err(r"\W+é+!").contains("too long"));
|
||||
assert!(err(r"[\D]+[٣]+!").contains("too long"));
|
||||
assert!(validate_pattern(r"\\w+\\w+!", false).is_ok(), "an escaped backslash, then `w`");
|
||||
assert!(validate_pattern(r"[0-9a-f]{32}", false).is_ok());
|
||||
// Anchored, the same shape tries one start instead of every position.
|
||||
assert!(validate_pattern(r"^\w+\w+!", false).is_ok());
|
||||
assert!(err(r"^.*a.*b.*c").contains("too long"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_constructs_javascript_reads_differently() {
|
||||
for pattern in [r"(?i)error", r"(?P<n>a)", r"(?=a)", r"\Aerror", r"error\z", r"\p{L}", r"[[:alpha:]]"] {
|
||||
assert!(err(pattern).contains("not supported"), "{pattern}");
|
||||
}
|
||||
assert!(err("(").contains("invalid pattern"));
|
||||
assert!(err("").contains("empty"));
|
||||
assert!(err(&"a".repeat(513)).contains("too long"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalizing_keeps_known_colours_and_styles_and_bounds_the_list() {
|
||||
let mut r = rule("x");
|
||||
r.foreground = Some("bright-cyan".into());
|
||||
r.background = Some("#ff0000".into());
|
||||
r.styles = vec!["bold".into(), "blink".into(), "bold".into(), "dim".into()];
|
||||
let out = normalize(vec![r, ConsoleRule { foreground: Some("teal".into()), ..rule("y") }]).unwrap();
|
||||
assert_eq!(out[0].foreground.as_deref(), Some("bright-cyan"));
|
||||
assert_eq!(out[0].background, None);
|
||||
assert_eq!(out[0].styles, ["bold", "dim"]);
|
||||
assert_eq!(out[1].foreground, None);
|
||||
|
||||
let e = normalize(vec![rule("ok"), rule(".*a.*b")]).unwrap_err();
|
||||
assert!(e.starts_with("console rule 1:"), "{e}");
|
||||
assert!(normalize(vec![rule("x"); MAX_RULES]).is_ok());
|
||||
assert!(normalize(vec![rule("x"); MAX_RULES + 1]).unwrap_err().contains("at most 100"));
|
||||
}
|
||||
}
|
||||
@@ -162,8 +162,7 @@ impl PluginHost {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// What a plugin receives for `document-changed`: the path relative to the file's own
|
||||
/// project, and that project's root, since two open projects can hold the same relative path.
|
||||
/// What a plugin receives for `document-changed`: the path relative to the file's own project.
|
||||
pub(super) fn relativize_documents(
|
||||
shared: &super::api::Shared,
|
||||
client: Option<&str>,
|
||||
@@ -182,7 +181,6 @@ impl PluginHost {
|
||||
.to_string_lossy()
|
||||
.replace('\\', "/");
|
||||
change.path = relative;
|
||||
change.project = Some(ide_core::ipc_path::to_ipc(&root));
|
||||
Some(WorkbenchEvent::DocumentChanged(change))
|
||||
})
|
||||
.collect()
|
||||
|
||||
@@ -30,7 +30,7 @@ pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn unsupported_construct(pattern: &str) -> Option<&'static str> {
|
||||
fn unsupported_construct(pattern: &str) -> Option<&'static str> {
|
||||
if pattern.match_indices("(?").any(|(at, _)| !pattern[at + 2..].starts_with(':')) {
|
||||
return Some("an inline flag, lookaround or named group");
|
||||
}
|
||||
|
||||
@@ -20,7 +20,6 @@ mod auth;
|
||||
mod build_graph;
|
||||
pub mod commands;
|
||||
pub mod commit;
|
||||
mod console_rules;
|
||||
mod database;
|
||||
mod dependencies;
|
||||
pub(crate) mod diagnostics;
|
||||
@@ -51,7 +50,6 @@ pub mod remote;
|
||||
pub mod remote_host;
|
||||
mod run_detectors;
|
||||
pub mod run_targets;
|
||||
pub mod search;
|
||||
mod semantic_tokens;
|
||||
mod snippets;
|
||||
mod theme;
|
||||
@@ -440,11 +438,6 @@ impl PluginHost {
|
||||
self.shared.decoration_sets()
|
||||
}
|
||||
|
||||
/// Every plugin's console highlight rules, for windows opening after they were set.
|
||||
pub fn console_rules(&self) -> std::collections::BTreeMap<String, Vec<ide_plugin::ConsoleRule>> {
|
||||
self.shared.console_rules()
|
||||
}
|
||||
|
||||
/// Creates the host; call [`load_all`](Self::load_all) to load installed plugins.
|
||||
pub fn new(plugins_dir: PathBuf, sink: Arc<dyn PluginEventSink>, limits: Limits) -> IdeResult<Self> {
|
||||
std::fs::create_dir_all(&plugins_dir)?;
|
||||
|
||||
@@ -76,7 +76,6 @@ pub fn register_builtin_points(
|
||||
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)))?;
|
||||
registry.register(Arc::new(UiPoint::new(super::search::POINT, ui.clone(), super::search::declaration)))?;
|
||||
registry.register(Arc::new(UiPoint::new(super::endpoints::POINT, ui.clone(), super::endpoints::declaration)))?;
|
||||
registry.register(Arc::new(UiPoint::new(
|
||||
"runConfigurations",
|
||||
|
||||
@@ -144,7 +144,6 @@ pub fn forwarded(event: &PluginEvent) -> bool {
|
||||
| PluginEvent::ContentTabReply { .. }
|
||||
| PluginEvent::OpenDiff { .. }
|
||||
| PluginEvent::DecorationsChanged { .. }
|
||||
| PluginEvent::ConsoleRulesChanged { .. }
|
||||
| PluginEvent::EditorOpen { .. }
|
||||
| PluginEvent::EditorRanges { .. }
|
||||
| PluginEvent::Notification { .. }
|
||||
|
||||
Loaded 100 of 938 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача