дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-17 07:05:39 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
7eed99745a | ||
|
|
ebc879dc8b | ||
|
|
7096a1c374 | ||
|
|
a1d4d6fb7f | ||
|
|
7596e95b76 | ||
|
|
cc471029d2 | ||
|
|
ee8afe39a2 | ||
|
|
5f606219b2 | ||
|
|
0590a255e8 | ||
|
|
32d5232010 | ||
|
|
382f5d71fa | ||
|
|
0cd7d9c30e | ||
|
|
dfbe87161b | ||
|
|
7a351fe4b0 | ||
|
|
153a184eac | ||
|
|
868f5b18d0 | ||
|
|
8d87b0de6e | ||
|
|
c791f2c34c | ||
|
|
a52e416ad5 | ||
|
|
a7464bf631 | ||
|
|
26810fbcbd | ||
|
|
72b17683c9 | ||
|
|
e916af15d4 | ||
|
|
88eeb57000 | ||
|
|
ba5c56ade8 | ||
|
|
88a5602239 | ||
|
|
907ed1d85f | ||
|
|
7f229acbd9 | ||
|
|
41bae970e0 | ||
|
|
44b5515432 | ||
|
|
64d5618cc7 | ||
|
|
1a21efa4aa | ||
|
|
72cf2f488e | ||
|
|
53495fbc26 | ||
|
|
224099992a | ||
|
|
0dafd649da | ||
|
|
d2c5532ccb | ||
|
|
a03923f744 | ||
|
|
8668fdd731 | ||
|
|
17e7b98cfc | ||
|
|
77e6679701 | ||
|
|
5a0bd7d1fc | ||
|
|
e6daffae76 | ||
|
|
2b69d64055 | ||
|
|
6c9556ef54 | ||
|
|
64ee712401 | ||
|
|
0ff491cce8 | ||
|
|
4ce661ee1f | ||
|
|
55e89eac1a | ||
|
|
fcc8467657 | ||
|
|
489dd408bb | ||
|
|
4010f61453 | ||
|
|
00bbc474c0 | ||
|
|
2f68c83bcd | ||
|
|
567e45f830 | ||
|
|
245679cef8 | ||
|
|
3f3ad03d7c | ||
|
|
03ee687353 | ||
|
|
2e9e2c1699 | ||
|
|
d84d8829c4 | ||
|
|
38dfa37c88 | ||
|
|
447560e505 | ||
|
|
9bf1f320eb | ||
|
|
921378d531 | ||
|
|
1531220eea | ||
|
|
96e80f2028 | ||
|
|
e4ac29486c | ||
|
|
540094d1ae | ||
|
|
a9ec26aa08 |
No files matched your search
Створено
+59
-44
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "ide-agent"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4169,7 +4169,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-analysis"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ast-grep-core",
|
||||
"ide-core",
|
||||
@@ -4183,7 +4183,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-android"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4194,7 +4194,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-build"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"chardetng",
|
||||
@@ -4212,7 +4212,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-cli"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"serde",
|
||||
@@ -4226,7 +4226,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-clipboard"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
@@ -4237,7 +4237,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-core"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4254,7 +4254,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-coverage"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-run",
|
||||
@@ -4268,7 +4268,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-dap"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"futures",
|
||||
@@ -4297,7 +4297,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-db"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bb8",
|
||||
@@ -4333,7 +4333,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-docker"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"serde",
|
||||
@@ -4346,7 +4346,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4367,7 +4367,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-fonts"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-text",
|
||||
@@ -4379,7 +4379,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-github"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vcs",
|
||||
@@ -4392,7 +4392,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-heap"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4410,7 +4410,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-host"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
@@ -4435,6 +4435,7 @@ dependencies = [
|
||||
"ide-index",
|
||||
"ide-jsonrpc",
|
||||
"ide-jvm-attach",
|
||||
"ide-jvm-inspect",
|
||||
"ide-language",
|
||||
"ide-lsp",
|
||||
"ide-mcp",
|
||||
@@ -4447,6 +4448,7 @@ dependencies = [
|
||||
"ide-search",
|
||||
"ide-spell",
|
||||
"ide-ssh",
|
||||
"ide-streams",
|
||||
"ide-syntax",
|
||||
"ide-terminal",
|
||||
"ide-text",
|
||||
@@ -4481,7 +4483,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-http"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
@@ -4500,7 +4502,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-index"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4522,7 +4524,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jdwp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-jvm-inspect",
|
||||
"proptest",
|
||||
@@ -4534,7 +4536,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jsonrpc"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"futures",
|
||||
@@ -4551,7 +4553,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-attach"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"tempfile",
|
||||
@@ -4560,7 +4562,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-jvm-inspect"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"serde",
|
||||
@@ -4571,7 +4573,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-language"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"criterion",
|
||||
@@ -4629,7 +4631,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-lsp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4657,7 +4659,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-mcp"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"dunce",
|
||||
@@ -4676,7 +4678,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-notebook"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"futures",
|
||||
"ide-core",
|
||||
@@ -4699,7 +4701,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-plugin"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4722,7 +4724,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-profiler"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-jvm-attach",
|
||||
@@ -4736,7 +4738,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-remote"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"futures",
|
||||
@@ -4756,7 +4758,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-run"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"encoding_rs",
|
||||
@@ -4780,7 +4782,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-scaffold"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-tools",
|
||||
@@ -4796,7 +4798,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-sdk"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"flate2",
|
||||
@@ -4819,7 +4821,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-search"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"encoding_rs",
|
||||
@@ -4840,7 +4842,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-spell"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"parking_lot",
|
||||
@@ -4853,7 +4855,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-ssh"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"flate2",
|
||||
@@ -4876,9 +4878,22 @@ dependencies = [
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-streams"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
"ide-syntax",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
"tree-sitter",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-syntax"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"ide-language",
|
||||
@@ -4893,7 +4908,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-terminal"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"ide-core",
|
||||
"libc",
|
||||
@@ -4906,7 +4921,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-text"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"ide-core",
|
||||
@@ -4919,7 +4934,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-tools"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"hex",
|
||||
@@ -4940,7 +4955,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vcs"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -4961,7 +4976,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-vfs"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"chardetng",
|
||||
"dunce",
|
||||
@@ -4987,7 +5002,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-web"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"dirs 6.0.0",
|
||||
"ide-core",
|
||||
@@ -5003,7 +5018,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ide-workspace"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"blake3",
|
||||
"dunce",
|
||||
@@ -6632,7 +6647,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openidea"
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"blake3",
|
||||
|
||||
+2
-1
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
|
||||
exclude = ["sdk", "plugins"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.46"
|
||||
version = "0.1.47"
|
||||
edition = "2024"
|
||||
rust-version = "1.96"
|
||||
license = "Apache-2.0"
|
||||
@@ -52,6 +52,7 @@ ide-jvm-attach = { path = "crates/ide-jvm-attach" }
|
||||
ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
|
||||
ide-jdwp = { path = "crates/ide-jdwp" }
|
||||
ide-heap = { path = "crates/ide-heap" }
|
||||
ide-streams = { path = "crates/ide-streams" }
|
||||
|
||||
# serialization & IPC typing
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
|
||||
@@ -14,20 +14,21 @@ use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
|
||||
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
|
||||
|
||||
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
|
||||
/// session's model: they describe that model only, and other models may offer different ones.
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
|
||||
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
|
||||
match run_once(shared, spec, prefer_stored).await {
|
||||
match run_once(shared, spec, prefer_stored, model).await {
|
||||
Err(err)
|
||||
if !prefer_stored
|
||||
&& crate::provider::is_copilot_provider(&spec.id)
|
||||
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
|
||||
&& super::auth_required(0, &err) =>
|
||||
{
|
||||
let retry = run_once(shared, spec, true).await;
|
||||
let retry = run_once(shared, spec, true, model).await;
|
||||
if retry.is_ok() {
|
||||
crate::provider::mark_prefer_stored_copilot_auth();
|
||||
}
|
||||
@@ -37,7 +38,12 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Dis
|
||||
}
|
||||
}
|
||||
|
||||
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
|
||||
async fn run_once(
|
||||
shared: &Arc<Shared>,
|
||||
spec: &ProviderSpec,
|
||||
strip_ambient: bool,
|
||||
selected_model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
let root = shared.paths.project_root.clone();
|
||||
let launch = spec.clone();
|
||||
let launch = tokio::task::spawn_blocking({
|
||||
@@ -47,28 +53,68 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
|
||||
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
|
||||
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
|
||||
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
|
||||
let _stop = crate::catalogs::KillPeer(peer.clone());
|
||||
let conn = Conn::new(peer.clone(), client);
|
||||
let work = async {
|
||||
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
|
||||
conn.initialize(&client_info()).await.map_err(discovery_error)?;
|
||||
let cwd_s = cwd.to_string_lossy().into_owned();
|
||||
// No project MCP during discovery: Cursor can spend a long time spawning servers.
|
||||
let new: Value = conn
|
||||
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(discovery_error)?;
|
||||
let mut options = config::options_of(&new);
|
||||
config::add_client_options(&launch.id, &mut options);
|
||||
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
|
||||
let levels = match (model, levels_for_model_from_slice(&options)) {
|
||||
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
|
||||
_ => BTreeMap::new(),
|
||||
};
|
||||
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
|
||||
let mut levels = BTreeMap::new();
|
||||
let has_config = new.get("configOptions").is_some_and(Value::is_array);
|
||||
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
|
||||
levels.insert(model.clone(), levels_for_model_from_slice(&options));
|
||||
}
|
||||
if let Some(selected) = selected_model
|
||||
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
|
||||
&& !levels.contains_key(selected)
|
||||
{
|
||||
let session =
|
||||
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
|
||||
let (method, mut params) = config::set_request(option, selected);
|
||||
params["sessionId"] = json!(session);
|
||||
updates.config.lock().session = Some(session.to_owned());
|
||||
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
|
||||
let settings = if let Some(settings) = selected_settings(&response, selected) {
|
||||
Some(settings)
|
||||
} else {
|
||||
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
|
||||
loop {
|
||||
let notified = updates.changed.notified();
|
||||
if let Some(settings) = updates
|
||||
.config
|
||||
.lock()
|
||||
.options
|
||||
.as_ref()
|
||||
.and_then(|options| selected_settings(options, selected))
|
||||
{
|
||||
return settings;
|
||||
}
|
||||
notified.await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.ok()
|
||||
};
|
||||
match settings {
|
||||
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
|
||||
// An agent on the legacy `models` field that says nothing more: the model has
|
||||
// no settings of its own, and switching to it must not fail.
|
||||
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
|
||||
None => return Err("The agent did not report settings for the selected model".to_owned()),
|
||||
};
|
||||
}
|
||||
let commands = updates
|
||||
.commands
|
||||
.lock()
|
||||
@@ -88,16 +134,38 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
struct DiscoveryUpdates {
|
||||
provider: String,
|
||||
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
|
||||
config: Mutex<DiscoveryConfig>,
|
||||
changed: tokio::sync::Notify,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct DiscoveryConfig {
|
||||
session: Option<String>,
|
||||
options: Option<Value>,
|
||||
}
|
||||
|
||||
impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update"
|
||||
&& let Some(update) = params.get("update")
|
||||
&& update["sessionUpdate"] == "available_commands_update"
|
||||
{
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
if method != "session/update" {
|
||||
return;
|
||||
}
|
||||
let Some(update) = params.get("update") else { return };
|
||||
match update["sessionUpdate"].as_str() {
|
||||
Some("available_commands_update") => {
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
}
|
||||
Some("config_option_update") => {
|
||||
let mut config = self.config.lock();
|
||||
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
|
||||
&& config.session.is_some()
|
||||
&& update.get("configOptions").is_some_and(Value::is_array)
|
||||
{
|
||||
config.options = Some(update.clone());
|
||||
self.changed.notify_one();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -106,8 +174,24 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
}
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
|
||||
let levels: Vec<_> = options
|
||||
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
|
||||
match error {
|
||||
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
|
||||
"Sign in required: the agent could not authenticate model discovery".into()
|
||||
}
|
||||
other => format!("The agent could not complete model discovery: {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
response.get("configOptions")?.as_array()?;
|
||||
let options = config::options_of(response);
|
||||
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
|
||||
current.is_none_or(|current| current == model).then_some(options)
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
|
||||
options
|
||||
.iter()
|
||||
.filter(|o| config::is_per_model_option(o))
|
||||
.cloned()
|
||||
@@ -121,6 +205,5 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<Agen
|
||||
}
|
||||
o
|
||||
})
|
||||
.collect();
|
||||
(!levels.is_empty()).then_some(levels)
|
||||
.collect()
|
||||
}
|
||||
@@ -45,9 +45,18 @@ struct Entry {
|
||||
error: Option<String>,
|
||||
flight: Option<watch::Receiver<bool>>,
|
||||
abort: Option<tokio::task::AbortHandle>,
|
||||
flight_model: Option<String>,
|
||||
requested_model: Option<String>,
|
||||
model_failures: HashMap<String, ModelFailure>,
|
||||
catalog: Option<CatalogData>,
|
||||
}
|
||||
|
||||
struct ModelFailure {
|
||||
completed: Instant,
|
||||
retry_at_ms: f64,
|
||||
error: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct CatalogData {
|
||||
@@ -204,6 +213,24 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
{
|
||||
return catalog.thought_levels.get(model).cloned();
|
||||
}
|
||||
drop(state);
|
||||
let cache = shared.known.lock();
|
||||
let known = cache.get(provider)?;
|
||||
known
|
||||
.catalogs
|
||||
.get(&shared.root_key())
|
||||
.map(|saved| &saved.catalog.thought_levels)
|
||||
.unwrap_or(&known.thought_levels)
|
||||
.get(model)
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
@@ -214,16 +241,27 @@ impl AgentCatalogs {
|
||||
|
||||
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
|
||||
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
|
||||
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
|
||||
let unknown_model = entry
|
||||
.requested_model
|
||||
.as_deref()
|
||||
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
|
||||
AgentModelCatalog {
|
||||
provider: provider.to_owned(),
|
||||
config: shared.config_for_new_task(catalog.config, provider),
|
||||
thought_levels: catalog.thought_levels,
|
||||
refreshing: entry.flight.is_some(),
|
||||
refreshed_at_ms: catalog.refreshed_at_ms,
|
||||
retry_at_ms: entry
|
||||
.retry_at_ms
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
|
||||
error: entry.error.clone(),
|
||||
retry_at_ms: model_failure
|
||||
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
|
||||
.map(|failure| failure.retry_at_ms)
|
||||
.or_else(|| {
|
||||
(!unknown_model)
|
||||
.then_some(entry.retry_at_ms)
|
||||
.flatten()
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
|
||||
}),
|
||||
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -233,6 +271,7 @@ impl AgentCatalogs {
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
force: bool,
|
||||
model: Option<&str>,
|
||||
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
|
||||
let key = Self::key(shared, &spec.id);
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
@@ -264,6 +303,7 @@ impl AgentCatalogs {
|
||||
let mut catalog = saved.catalog;
|
||||
if !matching {
|
||||
catalog.refreshed_at_ms = None;
|
||||
catalog.thought_levels.clear();
|
||||
}
|
||||
catalog
|
||||
});
|
||||
@@ -279,31 +319,73 @@ impl AgentCatalogs {
|
||||
error: None,
|
||||
flight: None,
|
||||
abort: None,
|
||||
flight_model: None,
|
||||
requested_model: None,
|
||||
model_failures: HashMap::new(),
|
||||
},
|
||||
);
|
||||
}
|
||||
let fallback =
|
||||
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
|
||||
state.generation += 1;
|
||||
let generation = state.generation;
|
||||
let entry = state.entries.get_mut(&key).expect("catalog entry");
|
||||
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
|
||||
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
|
||||
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
|
||||
let target = model
|
||||
.filter(|model| {
|
||||
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|
||||
|| (!fresh && catalog.model_option().is_none())
|
||||
})
|
||||
.map(str::to_owned);
|
||||
if model.is_some() && entry.requested_model.as_deref() != model {
|
||||
entry.requested_model = model.map(str::to_owned);
|
||||
}
|
||||
let superseded = model.is_some()
|
||||
&& entry.flight.is_some()
|
||||
&& (entry.flight_model.is_some() || target.is_some())
|
||||
&& entry.flight_model.as_deref() != target.as_deref();
|
||||
if superseded {
|
||||
if let Some(abort) = entry.abort.take() {
|
||||
abort.abort();
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.generation = generation;
|
||||
entry.flight_model = None;
|
||||
}
|
||||
let cooling = match target.as_ref() {
|
||||
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
|
||||
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
|
||||
};
|
||||
let eligible = !cooling && (target.is_some() || force || !fresh);
|
||||
let mut start = None;
|
||||
if entry.flight.is_none() && !cooling && (force || !fresh) {
|
||||
if entry.flight.is_none() && eligible {
|
||||
let (done, ready) = watch::channel(false);
|
||||
entry.flight = Some(ready);
|
||||
entry.flight_model = target.clone();
|
||||
entry.error = None;
|
||||
if let Some(model) = target.as_ref() {
|
||||
entry.model_failures.remove(model);
|
||||
}
|
||||
entry.retry_at_ms = None;
|
||||
start = Some((entry.generation, done));
|
||||
// Every flight has its own generation, including superseded model selections.
|
||||
entry.generation = generation;
|
||||
start = Some((entry.generation, target, done));
|
||||
}
|
||||
let snapshot = self.snapshot(shared, &spec.id, entry);
|
||||
let flight = entry.flight.clone();
|
||||
drop(state);
|
||||
if let Some((generation, done)) = start {
|
||||
if superseded && start.is_none() {
|
||||
self.broadcast(shared, &snapshot);
|
||||
}
|
||||
if let Some((generation, model, done)) = start {
|
||||
self.broadcast(shared, &snapshot);
|
||||
let coordinator = self.clone();
|
||||
let shared = shared.clone();
|
||||
let flight_key = key.clone();
|
||||
let task = shared.runtime.clone().spawn(async move {
|
||||
let result = discover(&shared, spec).await;
|
||||
coordinator.complete(&shared, flight_key, generation, result);
|
||||
let result = discover(&shared, spec, model.as_deref()).await;
|
||||
coordinator.complete(&shared, flight_key, generation, model, result);
|
||||
let _ = done.send(true);
|
||||
});
|
||||
// A subscriber can re-enter and change configuration during the start event.
|
||||
@@ -319,7 +401,14 @@ impl AgentCatalogs {
|
||||
(snapshot, flight)
|
||||
}
|
||||
|
||||
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
|
||||
fn complete(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
key: Key,
|
||||
generation: u64,
|
||||
model: Option<String>,
|
||||
result: Result<Discovered, String>,
|
||||
) {
|
||||
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == key.2)
|
||||
@@ -330,6 +419,7 @@ impl AgentCatalogs {
|
||||
if current.as_ref() != Some(&entry.context) {
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
entry.completed = None;
|
||||
entry.retry_at_ms = None;
|
||||
entry.error = None;
|
||||
@@ -340,12 +430,16 @@ impl AgentCatalogs {
|
||||
return;
|
||||
}
|
||||
let now = self.now();
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
if model.is_none() {
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
let success = match result {
|
||||
Ok(found) => {
|
||||
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
|
||||
let mut cache = shared.known.lock();
|
||||
let known = cache.entry(key.2.clone()).or_default();
|
||||
let mut catalog = CatalogData {
|
||||
@@ -354,7 +448,7 @@ impl AgentCatalogs {
|
||||
refreshed_at_ms: Some(self.epoch_ms()),
|
||||
};
|
||||
// Efforts sessions reported for models discovery doesn't read stay while listed.
|
||||
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
|
||||
for (model, levels) in previous.thought_levels {
|
||||
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
|
||||
catalog.thought_levels.insert(model, levels);
|
||||
}
|
||||
@@ -373,11 +467,30 @@ impl AgentCatalogs {
|
||||
entry.catalog = Some(catalog);
|
||||
shared.persist_known(&cache);
|
||||
entry.successful = Some(now);
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
entry.model_failures.retain(|model, _| {
|
||||
entry
|
||||
.catalog
|
||||
.as_ref()
|
||||
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
|
||||
});
|
||||
entry.error = None;
|
||||
true
|
||||
}
|
||||
Err(error) => {
|
||||
entry.error = Some(error);
|
||||
if let Some(model) = model {
|
||||
entry.model_failures.insert(
|
||||
model,
|
||||
ModelFailure {
|
||||
completed: now,
|
||||
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
|
||||
error,
|
||||
},
|
||||
);
|
||||
} else {
|
||||
entry.error = Some(error);
|
||||
}
|
||||
false
|
||||
}
|
||||
};
|
||||
@@ -448,18 +561,22 @@ impl AgentCatalogs {
|
||||
|
||||
impl crate::AgentManager {
|
||||
/// Return cached choices immediately and schedule discovery when eligible.
|
||||
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
|
||||
// Settings and environment secrets can change while this window is open.
|
||||
*self.shared.providers.write() =
|
||||
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
|
||||
}
|
||||
}
|
||||
|
||||
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
|
||||
async fn discover(
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
match spec.driver {
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
|
||||
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
|
||||
provider::Driver::Claude => {
|
||||
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
|
||||
@@ -484,7 +601,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
provider::Driver::Copilot => {
|
||||
if shared.uses_copilot_acp_fallback(&spec) {
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
return acp::discover::run(shared, &acp_spec).await;
|
||||
return acp::discover::run(shared, &acp_spec, model).await;
|
||||
}
|
||||
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
|
||||
Ok(found) => Ok(Discovered {
|
||||
@@ -513,7 +630,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
);
|
||||
shared.mark_copilot_acp_fallback(&spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
acp::discover::run(shared, &acp_spec).await
|
||||
acp::discover::run(shared, &acp_spec, model).await
|
||||
}
|
||||
Err(err) => Err(err.message),
|
||||
}
|
||||
|
||||
@@ -11,8 +11,10 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
notifications: mpsc::UnboundedSender<Value>,
|
||||
}
|
||||
|
||||
struct Harness {
|
||||
@@ -31,6 +33,10 @@ impl Drop for Live {
|
||||
|
||||
impl Harness {
|
||||
fn new() -> Self {
|
||||
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
|
||||
}
|
||||
|
||||
fn with_initialize(initialize: Value) -> Self {
|
||||
let (pending_tx, pending) = mpsc::unbounded_channel();
|
||||
let launches = Arc::new(AtomicUsize::new(0));
|
||||
let live = Arc::new(AtomicUsize::new(0));
|
||||
@@ -42,26 +48,53 @@ impl Harness {
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
let initialize = initialize.clone();
|
||||
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
|
||||
let (client_io, server_io) = tokio::io::duplex(1 << 16);
|
||||
let (read, mut write) = tokio::io::split(server_io);
|
||||
tokio::spawn(async move {
|
||||
let _guard = guard;
|
||||
let mut lines = BufReader::new(read).lines();
|
||||
while let Some(line) = lines.next_line().await.unwrap() {
|
||||
loop {
|
||||
let line = tokio::select! {
|
||||
line = lines.next_line() => match line.unwrap() {
|
||||
Some(line) => line,
|
||||
None => break,
|
||||
},
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let request: Value = serde_json::from_str(&line).unwrap();
|
||||
let id = &request["id"];
|
||||
if id.is_null() {
|
||||
continue;
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
|
||||
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
|
||||
"session/new" => {
|
||||
let (reply, result) = oneshot::channel();
|
||||
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
|
||||
let result = tokio::select! {
|
||||
result = result => result.unwrap(),
|
||||
_ = lines.next_line() => break,
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
notifications: notifications_tx.clone(),
|
||||
})
|
||||
.unwrap();
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
result = &mut result => break result.unwrap(),
|
||||
_ = lines.next_line() => return,
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
|
||||
@@ -190,7 +223,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
let mut events = events(&manager);
|
||||
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(cached.refreshing);
|
||||
assert_eq!(model_values(&cached), ["old", "retained"]);
|
||||
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
|
||||
@@ -204,13 +237,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
|
||||
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
assert_eq!(provider.config, fresh.config);
|
||||
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
|
||||
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
|
||||
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
@@ -229,7 +262,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
|
||||
@@ -241,16 +274,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
|
||||
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
|
||||
};
|
||||
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let catalog = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
|
||||
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
|
||||
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
|
||||
// Discovery again reads "first" only; "second" keeps what its session reported.
|
||||
advance(&catalogs, 60);
|
||||
while events.try_recv().is_ok() {}
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(efforts(&fresh, "first"), ["medium"]);
|
||||
@@ -273,7 +306,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(model_values(&cached), ["legacy"]);
|
||||
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
|
||||
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
|
||||
@@ -292,11 +325,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let pending = harness.next().await;
|
||||
for _ in 0..10 {
|
||||
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
}
|
||||
let commands = tokio::spawn({
|
||||
let first = first.clone();
|
||||
@@ -309,21 +342,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
assert_eq!(completed(&mut second_events).await, done);
|
||||
commands.await.unwrap().unwrap();
|
||||
for force in [false, true, false, true] {
|
||||
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
|
||||
}
|
||||
advance(&catalogs, 29);
|
||||
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
|
||||
let newer = completed(&mut first_events).await;
|
||||
assert_eq!(model_values(&newer), ["two"]);
|
||||
assert_eq!(completed(&mut second_events).await, newer);
|
||||
advance(&catalogs, 15 * 60 - 1);
|
||||
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
|
||||
completed(&mut first_events).await;
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -337,25 +370,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
|
||||
let success = completed(&mut events).await;
|
||||
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
|
||||
advance(&catalogs, 15 * 60);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, success.config);
|
||||
assert_eq!(failed.thought_levels, success.thought_levels);
|
||||
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
|
||||
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
|
||||
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
|
||||
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 29);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
|
||||
let recovered = completed(&mut events).await;
|
||||
assert_eq!(model_values(&recovered), ["recovered"]);
|
||||
@@ -370,21 +403,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let pending = harness.next().await;
|
||||
tokio::time::pause();
|
||||
tokio::time::advance(Duration::from_secs(4)).await;
|
||||
let failed = completed(&mut events).await;
|
||||
assert!(failed.error.as_deref().unwrap().contains("time"));
|
||||
assert!(failed.retry_at_ms.is_some());
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
tokio::time::resume();
|
||||
stopped(&harness).await;
|
||||
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
|
||||
assert!(pending.reply.is_closed());
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -398,16 +431,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "two");
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
let shown = first.refresh_models(PROVIDER, false).unwrap();
|
||||
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(shown.config, fresh.config);
|
||||
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
assert!(!shown.refreshing);
|
||||
@@ -415,7 +448,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
// A changed configuration also invalidates successful freshness/cooldown.
|
||||
configure(tmp.path(), "three");
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -425,7 +458,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
assert!(manager.refresh_models("missing-provider", true).is_err());
|
||||
assert!(manager.refresh_models("missing-provider", true, None).is_err());
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
@@ -437,18 +470,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs, &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -468,18 +501,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
let second = make_manager_at(&b, &models_file, catalogs, &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
|
||||
let a_catalog = completed(&mut first_events).await;
|
||||
second.refresh_models(PROVIDER, false).unwrap();
|
||||
second.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
|
||||
let b_catalog = completed(&mut second_events).await;
|
||||
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
|
||||
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
|
||||
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!cached.refreshing, "matching persisted context should retain freshness");
|
||||
assert_eq!(cached.config, expected.config);
|
||||
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
|
||||
@@ -488,7 +521,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
configure(&a, "new-account");
|
||||
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
|
||||
let mut events = events(&changed);
|
||||
let stale = changed.refresh_models(PROVIDER, false).unwrap();
|
||||
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
|
||||
assert!(stale.refreshed_at_ms.is_none());
|
||||
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
|
||||
@@ -505,7 +538,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "after");
|
||||
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
|
||||
@@ -513,7 +546,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
assert!(model_values(&discarded).is_empty());
|
||||
assert!(discarded.refreshed_at_ms.is_none());
|
||||
assert!(!tmp.path().join("models.json").exists());
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
|
||||
}
|
||||
@@ -526,13 +559,296 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
|
||||
let empty = completed(&mut events).await;
|
||||
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
|
||||
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
|
||||
}
|
||||
|
||||
fn selected_response(model: &str, effort: &[&str]) -> Value {
|
||||
let mut result = response(&[model], effort);
|
||||
if effort.is_empty() {
|
||||
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn config_notification(session: &str, result: &Value) -> Value {
|
||||
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": session,
|
||||
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
|
||||
} })
|
||||
}
|
||||
|
||||
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
|
||||
catalog.thought_levels[model]
|
||||
.iter()
|
||||
.filter(|option| option.category.as_deref() == Some("thought_level"))
|
||||
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let models = ["default", "second", "plain", "unknown"];
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
assert!(!original.thought_levels.contains_key("second"));
|
||||
|
||||
// A fresh catalog and its global cooldown must not delay an unknown selection.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let pending = harness.next().await;
|
||||
assert_eq!(pending.method, "session/set_config_option");
|
||||
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
|
||||
let mut second = selected_response("second", &["off", "auto", "max"]);
|
||||
second["configOptions"].as_array_mut().unwrap().push(json!({
|
||||
"id": "context_tier", "type": "select", "currentValue": "large",
|
||||
"options": [{ "value": "normal" }, { "value": "large" }]
|
||||
}));
|
||||
pending.reply.send(Ok(second)).unwrap();
|
||||
let learned = completed(&mut events).await;
|
||||
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
|
||||
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
|
||||
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
|
||||
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
|
||||
assert!(!learned.thought_levels.contains_key("unknown"));
|
||||
|
||||
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
|
||||
let plain = completed(&mut events).await;
|
||||
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
|
||||
for model in ["default", "second", "plain"] {
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
|
||||
}
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
assert!(!cached.refreshing);
|
||||
assert!(cached.thought_levels["plain"].is_empty());
|
||||
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
|
||||
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
|
||||
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let models = ["default", "unsupported", "other"];
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(reply).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, original.config);
|
||||
assert!(!failed.thought_levels.contains_key("unsupported"));
|
||||
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
|
||||
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
|
||||
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
// The failed model cannot block another model, and its cooldown survives that success.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
|
||||
assert!(completed(&mut events).await.error.is_none());
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
|
||||
let retried = completed(&mut events).await;
|
||||
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
|
||||
assert!(retried.error.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&first);
|
||||
let models = ["default", "second", "third"];
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
for _ in 0..5 {
|
||||
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
}
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let current = harness.next().await;
|
||||
assert_eq!(current.params["value"], "third");
|
||||
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
|
||||
stopped(&harness).await;
|
||||
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
assert_eq!(cached, fresh);
|
||||
assert_eq!(efforts(&cached, "third"), ["max"]);
|
||||
assert!(!cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(!known.refreshing);
|
||||
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
|
||||
let _ = obsolete.reply.send(Err("late failure".into()));
|
||||
stopped(&harness).await;
|
||||
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
// No cache is needed: the selected model is resolved in the same short-lived session.
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
|
||||
let notifications = selected.notifications;
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
|
||||
notifications
|
||||
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
|
||||
.unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
|
||||
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
|
||||
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.error.is_none(), "{:?}", catalog.error);
|
||||
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
|
||||
let replaced = completed(&mut events).await;
|
||||
assert_eq!(model_values(&replaced), ["default", "new"]);
|
||||
assert_eq!(efforts(&replaced, "default"), ["medium"]);
|
||||
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
|
||||
}));
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let mut initial = response(&["default", "second"], &["low"]);
|
||||
for option in initial["configOptions"].as_array_mut().unwrap() {
|
||||
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
|
||||
}
|
||||
harness.next().await.reply.send(Ok(initial)).unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_config_option");
|
||||
assert_eq!(
|
||||
selected.params,
|
||||
json!({
|
||||
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
|
||||
})
|
||||
);
|
||||
// Notifications may arrive before the request response as well as after it.
|
||||
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.thought_levels["second"].is_empty());
|
||||
assert_eq!(efforts(&catalog, "default"), ["low"]);
|
||||
}
|
||||
@@ -363,6 +363,7 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
model_choice: u64,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
@@ -621,7 +622,7 @@ impl AgentManager {
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == provider)
|
||||
{
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
@@ -954,19 +955,36 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let target = {
|
||||
let s = task.state.lock();
|
||||
let o =
|
||||
s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?;
|
||||
if !o.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
|
||||
let (target, model_choice, previous_levels) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
o.clone()
|
||||
if target.category.as_deref() == Some("model") {
|
||||
s.model_choice += 1;
|
||||
}
|
||||
let previous_levels =
|
||||
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
|
||||
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
|
||||
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
(target, s.model_choice, previous_levels)
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
|
||||
// choice first so the switch and slider move immediately.
|
||||
apply_config_choice(&task, option, &value);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
|
||||
@@ -976,36 +994,77 @@ impl AgentManager {
|
||||
let mut model_options = (target.category.as_deref() != Some("model")
|
||||
|| previous.as_deref() == Some(value.as_str()))
|
||||
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
if live.is_none()
|
||||
&& target.category.as_deref() == Some("model")
|
||||
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
|
||||
{
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
let mut error = None;
|
||||
if levels.is_none()
|
||||
&& let Some(spec) = self.shared.spec(&provider)
|
||||
{
|
||||
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
|
||||
error = catalog.error;
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
}
|
||||
// Another selection may have superseded this discovery while it was waiting.
|
||||
if task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
let Some(levels) = levels else {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(
|
||||
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
|
||||
));
|
||||
};
|
||||
let mut s = task.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
model_options = true;
|
||||
}
|
||||
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
let reply: Value = match live.peer.request(method, params, None).await {
|
||||
Ok(reply) => reply,
|
||||
Err(e) => {
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
if let Some(prev) = previous.clone() {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = previous.clone();
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::internal(task.describe(e)));
|
||||
}
|
||||
};
|
||||
if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut task.state.lock().task.config, options);
|
||||
model_options = true;
|
||||
} else if target.category.as_deref() == Some("model") {
|
||||
// Old model controls were removed above, so these came from an update
|
||||
// that preceded the response.
|
||||
model_options = task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
}
|
||||
}
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !model_options {
|
||||
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if !model_options && target.category.as_deref() == Some("model") {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
@@ -1583,6 +1642,7 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
@@ -3093,12 +3153,32 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
|
||||
})
|
||||
}
|
||||
|
||||
fn apply_config_choice(task: &Task, option: &str, value: &str) {
|
||||
fn restore_config_choice(
|
||||
task: &Task,
|
||||
target: &AgentConfigOption,
|
||||
value: &str,
|
||||
previous: Option<&str>,
|
||||
model_choice: u64,
|
||||
previous_levels: Option<Vec<AgentConfigOption>>,
|
||||
) {
|
||||
let option = target.id.as_str();
|
||||
let is_model = target.category.as_deref() == Some("model");
|
||||
let mut s = task.state.lock();
|
||||
if (is_model && s.model_choice != model_choice)
|
||||
|| !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value))
|
||||
{
|
||||
return;
|
||||
}
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
|
||||
if let Some(previous) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = Some(value.to_owned());
|
||||
o.current = previous.map(str::to_owned);
|
||||
}
|
||||
if let Some(levels) = previous_levels {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
|
||||
@@ -51,6 +51,7 @@ struct FakeAgent {
|
||||
/// Config options `session/new` reports after the model one (per-model efforts, say).
|
||||
extra_options: Mutex<Vec<Value>>,
|
||||
model_options: Mutex<HashMap<String, Vec<Value>>>,
|
||||
model_config_gate: Mutex<Option<std::sync::mpsc::Receiver<()>>>,
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
@@ -231,6 +232,12 @@ impl Handler for FakeAgent {
|
||||
std::thread::sleep(self.delay_config);
|
||||
}
|
||||
self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
|
||||
if params["configId"] == "model" {
|
||||
let gate = self.model_config_gate.lock().take();
|
||||
if let Some(gate) = gate {
|
||||
gate.recv().unwrap();
|
||||
}
|
||||
}
|
||||
if params["configId"] == "model" && !self.model_options.lock().is_empty() {
|
||||
return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
|
||||
}
|
||||
@@ -590,6 +597,7 @@ for line in sys.stdin:
|
||||
assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);
|
||||
assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));
|
||||
let restored = manager(root, Arc::new(FakeAgent::default()));
|
||||
restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap();
|
||||
assert_eq!(first, restored.commands("claude", None).await.unwrap());
|
||||
// The same handshake lists the models, so the composer has them before any task.
|
||||
for mgr in [&mgr, &restored] {
|
||||
@@ -1931,8 +1939,7 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
// After a model switch no session reported, picking that model again or changing
|
||||
// another setting must not record the task's effort-less copy as the model's levels.
|
||||
// Idle selections use cached model controls or discover them before the next prompt.
|
||||
for (option, value) in [("mode", "code"), ("model", "big")] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
@@ -1945,7 +1952,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
provider: "claude-acp".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
@@ -1957,18 +1964,165 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
{
|
||||
let small = restored.task(&task.id).unwrap();
|
||||
let small = small.state.lock();
|
||||
let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(
|
||||
effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(),
|
||||
["minimal", "medium"]
|
||||
);
|
||||
}
|
||||
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
|
||||
restored.set_config(&task.id, option, value.into()).await.unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap();
|
||||
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
|
||||
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
|
||||
let saved: HashMap<String, Known> =
|
||||
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
|
||||
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
|
||||
assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}");
|
||||
restored.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
agent.calls.lock().clear();
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
let config = current.state.lock().task.config.clone();
|
||||
let effort = config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
|
||||
restored.set_config(&task.id, "effort", "medium".into()).await.unwrap();
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(known.thought_levels["plain"].is_empty());
|
||||
assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big"));
|
||||
{
|
||||
let mut calls = agent.calls.lock();
|
||||
assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load"));
|
||||
assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2);
|
||||
calls.clear();
|
||||
}
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection");
|
||||
assert!(current.live.lock().is_none(), "discovery never mutates a task's live session");
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
agent.calls.lock().clear();
|
||||
assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err());
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("big"));
|
||||
assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort"));
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = Arc::new(manager(tmp.path(), agent.clone()));
|
||||
agent.calls.lock().clear();
|
||||
let (release, gate) = std::sync::mpsc::channel();
|
||||
*agent.model_config_gate.lock() = Some(gate);
|
||||
let first = tokio::spawn({
|
||||
let restored = restored.clone();
|
||||
let id = task.id.clone();
|
||||
async move { restored.set_config(&id, "model", "small".into()).await }
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while agent.model_config_gate.lock().is_some() {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let duplicate = restored.set_config(&task.id, "model", "small".into());
|
||||
tokio::pin!(duplicate);
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"),
|
||||
_ = tokio::task::yield_now() => {}
|
||||
}
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
release.send(()).unwrap();
|
||||
first.await.unwrap().unwrap();
|
||||
duplicate.await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("plain"));
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(catalog.thought_levels["plain"].is_empty());
|
||||
assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings");
|
||||
assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
for (effort, applied) in [("medium", true), ("high", false)] {
|
||||
|
||||
@@ -47,13 +47,20 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def resources = p.tasks.named('processResources')
|
||||
p.tasks.register('openideaUpdateResources') {{
|
||||
dependsOn resources
|
||||
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
|
||||
def update = {{ t ->
|
||||
t.dependsOn 'processResources'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def dir = p.tasks.getByName('processResources').destinationDir
|
||||
def manifest = new File({})
|
||||
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
|
||||
else p.tasks.create('openideaUpdateResources', update)
|
||||
}}
|
||||
"#,
|
||||
literal(&p.path),
|
||||
@@ -172,7 +179,16 @@ mod tests {
|
||||
assert_eq!(gradle.command, "/tools/gradlew");
|
||||
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
|
||||
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
|
||||
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
|
||||
assert!(
|
||||
script.contains("processResources")
|
||||
&& script.contains(".destinationDir\n")
|
||||
&& script.contains("setText(dir.absolutePath")
|
||||
);
|
||||
// `register` is Gradle 4.9+ (#3864).
|
||||
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
|
||||
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
|
||||
}
|
||||
|
||||
|
||||
@@ -30,7 +30,8 @@ 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)
|
||||
def sets = p.extensions.findByName('sourceSets')
|
||||
// Gradle 4.x has it as a convention property, not an extension.
|
||||
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
|
||||
if (sets != null) {
|
||||
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
|
||||
// and sets whose folders the `idea` plugin lists as test sources.
|
||||
@@ -51,9 +52,12 @@ def describe = { Project p ->
|
||||
}
|
||||
}
|
||||
try {
|
||||
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
|
||||
def java = p.extensions.findByName('java')
|
||||
def lv = java?.toolchain?.languageVersion?.getOrNull()
|
||||
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
|
||||
def lv = null
|
||||
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
|
||||
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
|
||||
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
|
||||
} catch (ignored) {}
|
||||
println '@openidea-model\t' + JsonOutput.toJson(m)
|
||||
}
|
||||
|
||||
@@ -1,13 +1,16 @@
|
||||
//! A Gradle project's resolved dependencies for the Dependency Analyzer:
|
||||
//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
|
||||
//! The reports it read are kept per build ([`save_gradle_report`]) until a build file
|
||||
//! changes, for readers that must not run Gradle themselves (plugins).
|
||||
|
||||
use crate::gradle;
|
||||
use crate::process;
|
||||
use crate::sync::{SyncOptions, error_summary};
|
||||
use crate::sync::{self, SyncOptions, error_summary};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
use std::sync::Mutex;
|
||||
|
||||
/// One line of the report: an occurrence of a dependency where it is requested.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -158,6 +161,54 @@ pub fn gradle_dependencies(
|
||||
Ok(parse_report(&out.text))
|
||||
}
|
||||
|
||||
/// A `dependencies` report of one project of a build for one configuration.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct GradleReport {
|
||||
/// Gradle path of the project (`:`, `:app`).
|
||||
pub project: String,
|
||||
pub configuration: String,
|
||||
pub dependencies: Vec<GradleDependency>,
|
||||
}
|
||||
|
||||
#[derive(Default, Serialize, Deserialize)]
|
||||
struct ReportCache {
|
||||
/// The build files the reports were read with ([`sync::hash_gradle_files`]).
|
||||
hash: String,
|
||||
reports: Vec<GradleReport>,
|
||||
}
|
||||
|
||||
const REPORT_CACHE: &str = "gradle-dependencies.json";
|
||||
|
||||
/// Keeps `report` with the build's other reports (`cache_dir` is the build's cache
|
||||
/// directory), replacing an earlier one of the same project and configuration. Reports
|
||||
/// read before a build file changed are dropped.
|
||||
pub fn save_gradle_report(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
model: &gradle::GradleModel,
|
||||
report: &GradleReport,
|
||||
) -> IdeResult<()> {
|
||||
// Reports of several configurations may finish together: one read-modify-write at a time.
|
||||
static SAVING: Mutex<()> = Mutex::new(());
|
||||
let _saving = SAVING.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let hash = sync::hash_gradle_files(&gradle::build_files(root, model));
|
||||
let mut cache = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE)
|
||||
.filter(|c| c.hash == hash)
|
||||
.unwrap_or_else(|| ReportCache { hash, reports: Vec::new() });
|
||||
cache.reports.retain(|r| (&r.project, &r.configuration) != (&report.project, &report.configuration));
|
||||
cache.reports.push(report.clone());
|
||||
sync::write_cache(cache_dir, REPORT_CACHE, &cache)
|
||||
}
|
||||
|
||||
/// The reports kept for the build, unless a build file changed since they were read.
|
||||
pub fn gradle_reports(root: &Path, cache_dir: &Path, model: &gradle::GradleModel) -> Vec<GradleReport> {
|
||||
let Some(cache) = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE) else { return Vec::new() };
|
||||
if cache.hash != sync::hash_gradle_files(&gradle::build_files(root, model)) {
|
||||
return Vec::new();
|
||||
}
|
||||
cache.reports
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -234,6 +285,37 @@ runtimeClasspath - Runtime classpath of source set 'main'.
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_are_kept_per_project_and_configuration_until_a_build_file_changes() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path();
|
||||
let cache = root.join("cache");
|
||||
std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
|
||||
std::fs::write(root.join("build.gradle"), "").unwrap();
|
||||
let model = gradle::load(root).unwrap();
|
||||
assert!(gradle_reports(root, &cache, &model).is_empty());
|
||||
let report = |project: &str, configuration: &str, version: &str| GradleReport {
|
||||
project: project.into(),
|
||||
configuration: configuration.into(),
|
||||
dependencies: vec![dep("org.a", "b", Some(version))],
|
||||
};
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "1.0")).unwrap();
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "compileClasspath", "1.0")).unwrap();
|
||||
// Reading a report again replaces what was read before.
|
||||
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "2.0")).unwrap();
|
||||
assert_eq!(
|
||||
gradle_reports(root, &cache, &model),
|
||||
[report(":app", "compileClasspath", "1.0"), report(":app", "runtimeClasspath", "2.0")]
|
||||
);
|
||||
// A comment changes nothing Gradle reads; a dependency does.
|
||||
std::fs::write(root.join("build.gradle"), "// notes").unwrap();
|
||||
assert_eq!(gradle_reports(root, &cache, &model).len(), 2);
|
||||
std::fs::write(root.join("build.gradle"), "dependencies { implementation 'org.a:b:3.0' }").unwrap();
|
||||
assert!(gradle_reports(root, &cache, &model).is_empty());
|
||||
save_gradle_report(root, &cache, &model, &report(":", "compileClasspath", "3.0")).unwrap();
|
||||
assert_eq!(gradle_reports(root, &cache, &model), [report(":", "compileClasspath", "3.0")]);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn runs_the_report_of_the_project_and_configuration() {
|
||||
|
||||
@@ -19,7 +19,7 @@ pub mod web;
|
||||
mod xml;
|
||||
|
||||
pub use gradle::{GradleModel, GradleProject, GradleTask};
|
||||
pub use gradle_deps::{GradleDependency, gradle_dependencies};
|
||||
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
|
||||
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
|
||||
pub use sbt::{SbtBuild, SbtProject};
|
||||
pub use sync::{
|
||||
@@ -127,10 +127,22 @@ pub fn gradle_external_roots(
|
||||
gradle::external_roots(root, dirs.iter().map(String::as_str))
|
||||
}
|
||||
|
||||
/// Directories of Maven POMs linked from outside `root`, outermost only.
|
||||
/// Reads just those explicit paths (no POM parse and no directory walk).
|
||||
pub fn maven_external_roots(root: &Path, linked: &[String]) -> Vec<PathBuf> {
|
||||
let dirs = maven::external_pom_dirs(root, linked);
|
||||
/// Directories outside `root`, outermost only, of Maven POMs linked from there and, in a
|
||||
/// trusted project, of the modules its reactor lists there (`<module>../service-a</module>`):
|
||||
/// extra content roots, as IDEA imports such modules with content roots of their own.
|
||||
/// Linked POMs are read as explicit paths; the reactor's POMs are parsed, but not their
|
||||
/// parents, and nothing walks directories. `cache_dir` holds the profiles chosen at the last sync.
|
||||
pub fn maven_external_roots(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
trusted: bool,
|
||||
) -> Vec<PathBuf> {
|
||||
let mut dirs = maven::external_pom_dirs(root, &settings.linked_projects);
|
||||
if trusted {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
dirs.extend(maven::reactor_external_dirs(root, &profiles, &settings.unlinked_projects));
|
||||
}
|
||||
let owned: Vec<String> = dirs.iter().map(|dir| dir.to_string_lossy().into_owned()).collect();
|
||||
gradle::external_roots(root, owned.iter().map(String::as_str))
|
||||
}
|
||||
@@ -251,6 +263,59 @@ mod tests {
|
||||
assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reactor_modules_outside_the_root_are_content_roots_of_a_trusted_project() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("workspace");
|
||||
let cache = base.join("cache");
|
||||
let write = |rel: &str, text: &str| {
|
||||
let path = base.join(rel).join("pom.xml");
|
||||
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
std::fs::write(path, format!("<project><artifactId>{rel}</artifactId>{text}</project>")).unwrap();
|
||||
};
|
||||
let reactor = |modules: &str| {
|
||||
format!(
|
||||
"<packaging>pom</packaging><modules>{modules}</modules>\
|
||||
<profiles><profile><id>extra</id><modules><module>../service-c</module></modules></profile></profiles>"
|
||||
)
|
||||
};
|
||||
let all = "<module>core</module><module>../service-a</module><module>..</module>";
|
||||
write("workspace", &reactor(all));
|
||||
write("workspace/core", "<modules><module>../../service-d</module></modules>");
|
||||
write("service-a", "<modules><module>impl</module><module>../service-e</module></modules>");
|
||||
for module in ["service-a/impl", "service-c", "service-d", "service-e", "unrelated"] {
|
||||
write(module, "");
|
||||
}
|
||||
// The folder holding the project is not a module beside it, nor are its other modules.
|
||||
write("", "<modules><module>workspace</module><module>unrelated</module></modules>");
|
||||
|
||||
let mut settings = ide_core::settings::MavenSettings::default();
|
||||
let roots = |settings: &ide_core::settings::MavenSettings, trusted| {
|
||||
maven_external_roots(&root, &cache, settings, trusted)
|
||||
};
|
||||
let (a, c, d, e) =
|
||||
(base.join("service-a"), base.join("service-c"), base.join("service-d"), base.join("service-e"));
|
||||
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
|
||||
assert!(roots(&settings, false).is_empty(), "Restricted Mode does not widen the index");
|
||||
|
||||
settings.active_profiles = "extra".into();
|
||||
assert_eq!(roots(&settings, true), [a.clone(), c.clone(), d.clone(), e.clone()]);
|
||||
save_maven_profiles(&cache, &["!extra".into()]).unwrap();
|
||||
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
|
||||
|
||||
settings.unlinked_projects = vec![a.join("pom.xml").to_string_lossy().replace('\\', "/")];
|
||||
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
|
||||
settings.unlinked_projects.clear();
|
||||
|
||||
write("workspace", &reactor("<module>core</module>"));
|
||||
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
|
||||
write("workspace/core", "");
|
||||
assert!(roots(&settings, true).is_empty());
|
||||
write("workspace", &reactor(all));
|
||||
assert_eq!(roots(&settings, true), [a, e]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_profiles_and_checkbox_choices_control_modules_before_sync() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -1235,6 +1235,86 @@ pub fn external_pom_dirs(root: &Path, linked: &[String]) -> Vec<PathBuf> {
|
||||
out
|
||||
}
|
||||
|
||||
type FileStamp = Option<(Option<std::time::SystemTime>, u64)>;
|
||||
|
||||
fn file_stamp(path: &Path) -> FileStamp {
|
||||
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
|
||||
}
|
||||
|
||||
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
|
||||
struct ReactorScan {
|
||||
stamps: Vec<(PathBuf, FileStamp)>,
|
||||
dirs: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
|
||||
/// (`<module>../service-a</module>`), with their own modules in turn, including those of
|
||||
/// the active `profiles`. An `unlinked` POM leaves out its modules too. A folder that
|
||||
/// holds `root` (`<module>..</module>`) is not a module beside the project and is skipped.
|
||||
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
|
||||
/// sizes: content roots are read on hot paths (every references search, Find in Files).
|
||||
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
|
||||
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
|
||||
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
|
||||
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
|
||||
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
|
||||
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
|
||||
{
|
||||
return scan.dirs.clone();
|
||||
}
|
||||
let scan = scan_reactor(root, profiles, unlinked);
|
||||
let dirs = scan.dirs.clone();
|
||||
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
|
||||
fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
|
||||
let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
|
||||
let chosen = Resolver::new(None, profiles);
|
||||
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
|
||||
let first = root.join("pom.xml");
|
||||
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
|
||||
let mut seen: HashSet<PathBuf> = HashSet::new();
|
||||
let mut pending = vec![first];
|
||||
while let Some(path) = pending.pop() {
|
||||
if seen.len() >= MAX_PROJECTS {
|
||||
break;
|
||||
}
|
||||
let canonical = dunce::canonicalize(&path).unwrap_or_else(|_| path.clone());
|
||||
if !seen.insert(canonical.clone()) || unlinked.contains(&project_rel(&canonical_root, &canonical)) {
|
||||
continue;
|
||||
}
|
||||
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
|
||||
let dir = path.parent().unwrap_or(root).to_path_buf();
|
||||
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
|
||||
if !dir_canon.starts_with(&canonical_root) {
|
||||
if canonical_root.starts_with(&dir_canon) {
|
||||
continue;
|
||||
}
|
||||
scan.dirs.push(dir_canon);
|
||||
}
|
||||
let active: Vec<&RawProfile> = chosen.active(&pom.profiles).collect();
|
||||
let props: HashMap<String, String> =
|
||||
pom.properties.iter().chain(active.iter().flat_map(|p| &p.properties)).cloned().collect();
|
||||
for module in pom.modules.iter().chain(active.iter().flat_map(|p| &p.modules)) {
|
||||
let module = interpolate(module, &props);
|
||||
if module.contains("${") {
|
||||
continue;
|
||||
}
|
||||
let mut mp = crate::gradle::normalize(&dir.join(module));
|
||||
if mp.is_dir() || mp.extension().is_none_or(|e| e != "xml") {
|
||||
mp.push("pom.xml");
|
||||
}
|
||||
scan.stamps.push((mp.clone(), file_stamp(&mp)));
|
||||
if mp.is_file() {
|
||||
pending.push(mp);
|
||||
}
|
||||
}
|
||||
}
|
||||
scan
|
||||
}
|
||||
|
||||
/// Whether `root` holds a Maven build or the settings link one inside it.
|
||||
pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
|
||||
is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
|
||||
@@ -2479,8 +2559,12 @@ mod tests {
|
||||
assert_eq!(normalized[0], dunce::canonicalize(b.join("pom.xml")).unwrap().to_string_lossy().replace('\\', "/"));
|
||||
assert_eq!(normalized[1], "pom.xml");
|
||||
assert_eq!(normalized[2], "stub/pom.xml");
|
||||
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
|
||||
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
|
||||
let external_roots = |linked: &[String]| {
|
||||
let settings = ide_core::settings::MavenSettings { linked_projects: linked.to_vec(), ..Default::default() };
|
||||
crate::maven_external_roots(&a, &base.join("cache"), &settings, true)
|
||||
};
|
||||
assert_eq!(external_roots(&normalized), vec![b.clone()]);
|
||||
assert_eq!(external_roots(&stored), vec![b.clone()]);
|
||||
|
||||
let removed = load_with_linked(&a, None, &[], &[]);
|
||||
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
|
||||
|
||||
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
|
||||
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
|
||||
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
|
||||
}
|
||||
|
||||
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
|
||||
pub(crate) fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
let tmp = dir.join(format!("{name}.tmp"));
|
||||
@@ -156,7 +156,7 @@ fn hash_files(files: &[PathBuf]) -> String {
|
||||
|
||||
/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
|
||||
/// does not make the last sync stale.
|
||||
fn hash_gradle_files(files: &[PathBuf]) -> String {
|
||||
pub(crate) fn hash_gradle_files(files: &[PathBuf]) -> String {
|
||||
hash_contents(files, |f| {
|
||||
let text = std::fs::read_to_string(f).unwrap_or_default();
|
||||
let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
|
||||
|
||||
@@ -172,13 +172,25 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
|
||||
fs::write(
|
||||
&script,
|
||||
format!(
|
||||
r#"gradle.projectsEvaluated {{
|
||||
r#"import org.gradle.util.GradleVersion
|
||||
|
||||
gradle.projectsEvaluated {{
|
||||
def p = gradle.rootProject.project({})
|
||||
def warTask = p.tasks.named('war')
|
||||
p.tasks.register('openideaTomcatArtifact') {{
|
||||
dependsOn warTask
|
||||
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
|
||||
def artifact = {{ t ->
|
||||
t.dependsOn 'war'
|
||||
// Resolved here so the action holds no task or project (configuration cache).
|
||||
def war = p.tasks.getByName('war')
|
||||
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
|
||||
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
|
||||
def manifest = new File({})
|
||||
t.doLast {{
|
||||
def file = archive instanceof File ? archive : archive.get().asFile
|
||||
manifest.setText(file.absolutePath, 'UTF-8')
|
||||
}}
|
||||
}}
|
||||
// `register` is Gradle 4.9+.
|
||||
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
|
||||
else p.tasks.create('openideaTomcatArtifact', artifact)
|
||||
}}
|
||||
"#,
|
||||
groovy_literal(path),
|
||||
@@ -270,7 +282,7 @@ mod tests {
|
||||
assert_eq!(a.len(), 1);
|
||||
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
|
||||
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
|
||||
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
|
||||
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
|
||||
}
|
||||
|
||||
@@ -297,7 +309,14 @@ mod tests {
|
||||
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
|
||||
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
|
||||
assert!(script.contains(&format!("rootProject.project('{}')", module)));
|
||||
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
|
||||
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
|
||||
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
|
||||
assert!(
|
||||
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
|
||||
);
|
||||
// The configuration cache can't serialize a task or project the action refers to.
|
||||
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
|
||||
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -343,6 +343,8 @@ pub struct InlayHintsSettings {
|
||||
/// Hints of other kinds (chaining, closing labels…).
|
||||
pub other: bool,
|
||||
pub disabled_languages: Vec<String>,
|
||||
/// Code vision as a whole (usages, author and language-server lenses); the switches below apply while it is on.
|
||||
pub code_vision: bool,
|
||||
/// Code vision: usages above declarations.
|
||||
pub code_vision_usages: bool,
|
||||
/// Code vision: last author of a declaration (VCS blame) beside its usages.
|
||||
@@ -373,6 +375,7 @@ impl Default for InlayHintsSettings {
|
||||
parameters: true,
|
||||
other: true,
|
||||
disabled_languages: Vec::new(),
|
||||
code_vision: true,
|
||||
code_vision_usages: true,
|
||||
code_vision_author: true,
|
||||
code_vision_no_usages: true,
|
||||
|
||||
@@ -167,10 +167,11 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
|
||||
/// Gradle's own JVM and the compiler's source encoding are untouched.
|
||||
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
|
||||
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects {
|
||||
tasks.withType(JavaExec).configureEach {
|
||||
defaultCharacterEncoding = 'UTF-8'
|
||||
}
|
||||
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
|
||||
}
|
||||
";
|
||||
|
||||
@@ -621,10 +622,12 @@ mod tests {
|
||||
#[test]
|
||||
fn gradle_script_respects_the_builds_own_file_encoding() {
|
||||
let s = GRADLE_FILE_ENCODING_SCRIPT;
|
||||
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
|
||||
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
|
||||
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
|
||||
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
|
||||
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
|
||||
// Gradle before 4.9 has no `configureEach` (#3864).
|
||||
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
|
||||
#[cfg(windows)]
|
||||
pub fn windows_build_number() -> Option<u32> {
|
||||
@@ -16,6 +19,61 @@ pub fn windows_build_number() -> Option<u32> {
|
||||
None
|
||||
}
|
||||
|
||||
/// A caption button of a frameless window's title bar.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum WindowButton {
|
||||
Minimize,
|
||||
Maximize,
|
||||
Close,
|
||||
}
|
||||
|
||||
/// Which caption buttons the title bar shows on each side, in order from left to right.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct WindowButtonLayout {
|
||||
pub left: Vec<WindowButton>,
|
||||
pub right: Vec<WindowButton>,
|
||||
}
|
||||
|
||||
impl Default for WindowButtonLayout {
|
||||
/// Minimise, maximise, close on the right (Windows, and Linux when the desktop says nothing).
|
||||
fn default() -> Self {
|
||||
Self { left: Vec::new(), right: vec![WindowButton::Minimize, WindowButton::Maximize, WindowButton::Close] }
|
||||
}
|
||||
}
|
||||
|
||||
impl WindowButtonLayout {
|
||||
/// Reads GTK's `gtk-decoration-layout` (also GNOME's `button-layout`): button names separated
|
||||
/// by commas, the left side before the colon, e.g. `close,maximize,minimize:icon`. Names other
|
||||
/// than the three caption buttons (`icon`, `menu`, `appmenu`, `spacer`) are skipped, as are
|
||||
/// repeats. A value without any caption button is unusable for a frameless window: `None`.
|
||||
pub fn from_gtk_decoration_layout(layout: &str) -> Option<Self> {
|
||||
let mut seen = Vec::new();
|
||||
let mut side = |part: Option<&str>| {
|
||||
let mut buttons = Vec::new();
|
||||
for name in part.unwrap_or_default().split(',') {
|
||||
let button = match name.trim() {
|
||||
"minimize" => WindowButton::Minimize,
|
||||
"maximize" => WindowButton::Maximize,
|
||||
"close" => WindowButton::Close,
|
||||
_ => continue,
|
||||
};
|
||||
if !seen.contains(&button) {
|
||||
seen.push(button);
|
||||
buttons.push(button);
|
||||
}
|
||||
}
|
||||
buttons
|
||||
};
|
||||
// GTK splits at the first colon only; without one, every button is on the left.
|
||||
let mut parts = layout.splitn(2, ':');
|
||||
let left = side(parts.next());
|
||||
let right = side(parts.next());
|
||||
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
@@ -26,4 +84,42 @@ mod tests {
|
||||
#[cfg(not(windows))]
|
||||
assert_eq!(build, None);
|
||||
}
|
||||
|
||||
use super::{WindowButton::*, WindowButtonLayout};
|
||||
|
||||
fn layout(left: &[super::WindowButton], right: &[super::WindowButton]) -> Option<WindowButtonLayout> {
|
||||
Some(WindowButtonLayout { left: left.to_vec(), right: right.to_vec() })
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_gtk_decoration_layouts() {
|
||||
let cases = [
|
||||
// KDE Plasma with `ButtonsOnLeft=XAIS` (#3794).
|
||||
("close,maximize,minimize:icon", layout(&[Close, Maximize, Minimize], &[])),
|
||||
("close,minimize,maximize:", layout(&[Close, Minimize, Maximize], &[])),
|
||||
(":minimize,maximize,close", layout(&[], &[Minimize, Maximize, Close])),
|
||||
// GNOME's default.
|
||||
("appmenu:close", layout(&[], &[Close])),
|
||||
("menu:minimize,close", layout(&[], &[Minimize, Close])),
|
||||
("icon,close:minimize,maximize", layout(&[Close], &[Minimize, Maximize])),
|
||||
(" close , spacer : minimize ", layout(&[Close], &[Minimize])),
|
||||
// No colon: GTK puts everything on the left.
|
||||
("close,minimize", layout(&[Close, Minimize], &[])),
|
||||
// Only the first colon separates the sides; a button appears once.
|
||||
("close:minimize:maximize", layout(&[Close], &[])),
|
||||
("close,close:close,minimize", layout(&[Close], &[Minimize])),
|
||||
("", None),
|
||||
(":", None),
|
||||
("appmenu:", None),
|
||||
("garbage", None),
|
||||
];
|
||||
for (value, expected) in cases {
|
||||
assert_eq!(WindowButtonLayout::from_gtk_decoration_layout(value), expected, "{value:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_layout_is_on_the_right() {
|
||||
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
|
||||
}
|
||||
}
|
||||
@@ -653,6 +653,10 @@ pub struct NotificationSettings {
|
||||
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
|
||||
#[serde(default = "default_true")]
|
||||
pub system_notifications: bool,
|
||||
/// Terminal command completions (#3712): `off` | `longRunning` | `all`.
|
||||
pub terminal_completion: String,
|
||||
/// `longRunning`: the run time a finished command must reach, in seconds.
|
||||
pub terminal_threshold_seconds: u32,
|
||||
/// Group id → display; groups not listed use their default.
|
||||
pub groups: BTreeMap<String, NotificationGroupSettings>,
|
||||
}
|
||||
@@ -661,9 +665,24 @@ fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn default_terminal_completion() -> String {
|
||||
"longRunning".to_owned()
|
||||
}
|
||||
|
||||
fn default_terminal_threshold_seconds() -> u32 {
|
||||
10
|
||||
}
|
||||
|
||||
impl Default for NotificationSettings {
|
||||
fn default() -> Self {
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
Self {
|
||||
balloons: true,
|
||||
sound: false,
|
||||
system_notifications: true,
|
||||
terminal_completion: default_terminal_completion(),
|
||||
terminal_threshold_seconds: default_terminal_threshold_seconds(),
|
||||
groups: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -741,6 +760,9 @@ pub struct AppearanceSettings {
|
||||
pub main_menu_style: String,
|
||||
/// A lone Alt press focuses or opens the main menu (IDEA `ide.windows.main.menu.focus.on.alt`).
|
||||
pub main_menu_alt: bool,
|
||||
/// Settings open in a native window of their own (IDEA parity); off opens them
|
||||
/// as a dialog inside the project window, which needs no new webview.
|
||||
pub settings_in_separate_window: bool,
|
||||
/// `subpixel` | `greyscale` | `none`
|
||||
pub ide_antialiasing: String,
|
||||
pub editor_antialiasing: String,
|
||||
@@ -840,6 +862,7 @@ impl Default for AppearanceSettings {
|
||||
menu_icons: true,
|
||||
main_menu_style: "hamburger".into(),
|
||||
main_menu_alt: true,
|
||||
settings_in_separate_window: true,
|
||||
ide_antialiasing: "greyscale".into(),
|
||||
editor_antialiasing: "greyscale".into(),
|
||||
show_tool_window_bars: true,
|
||||
@@ -892,7 +915,13 @@ pub struct EditorSettings {
|
||||
pub docstring_format: String,
|
||||
/// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
|
||||
pub rainbow_brackets: bool,
|
||||
/// The bracket kinds rainbow brackets colour.
|
||||
pub rainbow_bracket_kinds: RainbowBracketKinds,
|
||||
/// Colours the rainbow bracket depth cycles through (2–5).
|
||||
pub rainbow_bracket_colors: u32,
|
||||
pub ligatures: bool,
|
||||
/// Editor › Font and Tools › Terminal › Font: the font pickers list only monospaced fonts.
|
||||
pub only_monospaced_fonts: bool,
|
||||
/// Fallback font for glyphs the main font lacks; empty = none.
|
||||
pub fallback_font: String,
|
||||
/// Typography Settings › Main font weight (CSS 100–900), as IDEA.
|
||||
@@ -936,7 +965,10 @@ impl Default for EditorSettings {
|
||||
semantic_highlighting: false,
|
||||
docstring_format: "rest".into(),
|
||||
rainbow_brackets: false,
|
||||
rainbow_bracket_kinds: RainbowBracketKinds::default(),
|
||||
rainbow_bracket_colors: 3,
|
||||
ligatures: false,
|
||||
only_monospaced_fonts: true,
|
||||
fallback_font: String::new(),
|
||||
font_weight: 400,
|
||||
bold_font_weight: 700,
|
||||
@@ -959,6 +991,23 @@ impl Default for EditorSettings {
|
||||
}
|
||||
}
|
||||
|
||||
/// Color Scheme › Language Defaults › Rainbow brackets: which delimiters are coloured.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct RainbowBracketKinds {
|
||||
pub round: bool,
|
||||
pub square: bool,
|
||||
pub curly: bool,
|
||||
/// Type argument / parameter delimiters and markup tags, where the syntax tree marks them.
|
||||
pub angle: bool,
|
||||
}
|
||||
|
||||
impl Default for RainbowBracketKinds {
|
||||
fn default() -> Self {
|
||||
Self { round: true, square: true, curly: true, angle: false }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FileSettings {
|
||||
@@ -1751,6 +1800,41 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rainbow_bracket_options_default_and_round_trip() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"rainbowBrackets":true}}"#).unwrap();
|
||||
assert!(old.editor.rainbow_brackets);
|
||||
assert_eq!(old.editor.rainbow_bracket_kinds, RainbowBracketKinds::default());
|
||||
assert_eq!(old.editor.rainbow_bracket_colors, 3);
|
||||
let defaults = Settings::default().editor;
|
||||
assert!(!defaults.rainbow_brackets);
|
||||
let kinds = defaults.rainbow_bracket_kinds;
|
||||
assert!(kinds.round && kinds.square && kinds.curly && !kinds.angle);
|
||||
|
||||
let mut settings = Settings::default();
|
||||
settings.editor.rainbow_bracket_kinds =
|
||||
RainbowBracketKinds { round: false, square: true, curly: true, angle: true };
|
||||
settings.editor.rainbow_bracket_colors = 5;
|
||||
let json = serde_json::to_value(&settings).unwrap();
|
||||
assert_eq!(json["editor"]["rainbowBracketKinds"]["angle"], true);
|
||||
assert_eq!(json["editor"]["rainbowBracketColors"], 5);
|
||||
let restored: Settings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(restored.editor.rainbow_bracket_kinds, settings.editor.rainbow_bracket_kinds);
|
||||
assert_eq!(restored.editor.rainbow_bracket_colors, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_monospaced_fonts_defaults_on_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"ligatures":true}}"#).unwrap();
|
||||
assert!(old.editor.only_monospaced_fonts);
|
||||
let mut settings = Settings::default();
|
||||
settings.editor.only_monospaced_fonts = false;
|
||||
let json = serde_json::to_value(&settings).unwrap();
|
||||
assert_eq!(json["editor"]["onlyMonospacedFonts"], false);
|
||||
let restored: Settings = serde_json::from_value(json).unwrap();
|
||||
assert!(!restored.editor.only_monospaced_fonts);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn docstring_format_defaults_and_round_trips() {
|
||||
let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
|
||||
@@ -1849,6 +1933,15 @@ mod tests {
|
||||
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["mainMenuAlt"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_open_in_a_separate_window_unless_turned_off() {
|
||||
let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
|
||||
assert!(old.appearance.settings_in_separate_window);
|
||||
let off: Settings = serde_json::from_str(r#"{"appearance":{"settingsInSeparateWindow":false}}"#).unwrap();
|
||||
assert!(!off.appearance.settings_in_separate_window);
|
||||
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["settingsInSeparateWindow"], false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_font_weights_default_to_regular_and_bold() {
|
||||
let json = serde_json::to_value(Settings::default()).unwrap();
|
||||
|
||||
@@ -43,6 +43,9 @@ impl Default for VcsSettings {
|
||||
pub struct GitSettings {
|
||||
/// Show blame after the current editor line.
|
||||
pub inline_blame: bool,
|
||||
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
@@ -54,6 +57,8 @@ pub struct GitSettings {
|
||||
pub warn_detached_head: bool,
|
||||
/// Background check for incoming commits: `auto` | `always` | `never`.
|
||||
pub incoming_check: String,
|
||||
/// Minutes between background checks for incoming commits.
|
||||
pub incoming_check_interval: u32,
|
||||
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
|
||||
pub protected_branches: String,
|
||||
/// Initial state of Commit Options › Sign-off Commit.
|
||||
@@ -78,6 +83,7 @@ impl Default for GitSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
@@ -85,6 +91,7 @@ impl Default for GitSettings {
|
||||
warn_crlf: true,
|
||||
warn_detached_head: true,
|
||||
incoming_check: "auto".into(),
|
||||
incoming_check_interval: 15,
|
||||
protected_branches: "master; main".into(),
|
||||
sign_off: false,
|
||||
warn_large_files: true,
|
||||
|
||||
@@ -6,11 +6,16 @@ use ide_run::wrap::{self, program_name};
|
||||
use std::path::Path;
|
||||
|
||||
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
|
||||
allprojects {
|
||||
plugins.withId('java') {
|
||||
apply plugin: 'jacoco'
|
||||
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
|
||||
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
|
||||
import org.gradle.util.GradleVersion
|
||||
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
|
||||
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
|
||||
allprojects { p ->
|
||||
p.plugins.withId('java') {
|
||||
p.apply plugin: 'jacoco'
|
||||
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
|
||||
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
|
||||
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
|
||||
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
|
||||
}
|
||||
}
|
||||
"#;
|
||||
@@ -391,7 +396,10 @@ mod tests {
|
||||
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
|
||||
let (l, report) = launch(&p);
|
||||
assert_eq!(l.args[0], "--init-script");
|
||||
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
|
||||
let script = std::fs::read_to_string(&l.args[1]).unwrap();
|
||||
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
|
||||
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
|
||||
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
|
||||
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
|
||||
}
|
||||
|
||||
|
||||
@@ -216,6 +216,11 @@ fn settle<T>(result: Result<T, InspectError>) -> IdeResult<Result<T, JvmInspectU
|
||||
InspectError::TimedOut => U::TimedOut,
|
||||
InspectError::Closed => U::BackendClosed,
|
||||
InspectError::Failed(message) => return Err(IdeError::internal(format!("JVM inspector: {message}"))),
|
||||
// Only the stream trace commands answer these, never the memory view's.
|
||||
other @ (InspectError::NoSession
|
||||
| InspectError::NotAtChainStart(_)
|
||||
| InspectError::Busy
|
||||
| InspectError::NoTrace) => return Err(IdeError::internal(format!("JVM inspector: {other}"))),
|
||||
}))
|
||||
}
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ use std::time::Duration;
|
||||
|
||||
pub use heap::*;
|
||||
pub use inspect::{JvmFieldsResult, JvmInspectUnavailable, JvmInstancesResult, JvmObjectRef, JvmReferrersResult};
|
||||
pub(crate) use inspect::{fields, instances, referrers, set_inspector, watch_link};
|
||||
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, watch_link};
|
||||
#[cfg(all(test, unix))]
|
||||
pub(crate) use scan::watch_for_attached_jvm;
|
||||
pub(crate) use scan::{JvmFinder, attach_target, find_attached_jvm, find_local_jvm, local_jdwp_port};
|
||||
|
||||
@@ -19,6 +19,7 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
mod stream_trace;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
@@ -39,6 +40,7 @@ use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::sync::{Arc, Weak};
|
||||
use std::time::Duration;
|
||||
pub use stream_trace::{TracePhase, TraceProgress, TraceRun, TraceUnavailable};
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -146,6 +148,9 @@ pub struct DebugCapabilities {
|
||||
pub js_page: bool,
|
||||
/// The adapter evaluates expressions while the program runs, without a stack frame.
|
||||
pub live_evaluate: bool,
|
||||
/// A stream chain can be traced while the program runs it ([`DebugManager::stream_trace`]).
|
||||
/// Can change during the session, like `jvm_instances`.
|
||||
pub stream_trace: bool,
|
||||
}
|
||||
|
||||
/// Result of [`DebugManager::redefine_classes`].
|
||||
@@ -602,6 +607,7 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
|
||||
jvm_heap: false,
|
||||
js_page: false,
|
||||
live_evaluate: false,
|
||||
stream_trace: false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -613,6 +619,7 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities {
|
||||
caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str());
|
||||
caps.js_page = js_debug::is_page(session);
|
||||
caps.live_evaluate = session.adapter == js_debug::ADAPTER;
|
||||
caps.stream_trace = stream_trace::available(session);
|
||||
caps
|
||||
}
|
||||
|
||||
@@ -1617,6 +1624,7 @@ impl DebugManager {
|
||||
// DAP: a response without the flag continued every thread.
|
||||
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
|
||||
session.suspended.resumed(ticket, thread_id, all);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1665,6 +1673,7 @@ impl DebugManager {
|
||||
step_settled(&session, sent)?;
|
||||
// A step runs its thread; other threads stopped by their own events stay stopped.
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1776,6 +1785,7 @@ impl DebugManager {
|
||||
.await;
|
||||
step_settled(&session, sent)?;
|
||||
session.suspended.resumed(ticket, thread_id, false);
|
||||
stream_trace::release_done(&session);
|
||||
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
|
||||
Ok(())
|
||||
}
|
||||
@@ -1873,6 +1883,42 @@ impl DebugManager {
|
||||
jvm_memory::referrers(&*self.session(s)?, object, limit).await
|
||||
}
|
||||
|
||||
/// Gives the session the backend for [`Self::stream_trace`] (used by java-debug sessions
|
||||
/// only); the UI is told to reload the session's capabilities.
|
||||
pub fn set_stream_tracer(
|
||||
&self,
|
||||
s: DebugSessionId,
|
||||
tracer: Arc<dyn ide_jvm_inspect::StreamTracer>,
|
||||
) -> IdeResult<()> {
|
||||
let session = self.session(s)?;
|
||||
if session.ended.is_cancelled() {
|
||||
return Err(no_session(s));
|
||||
}
|
||||
stream_trace::set_tracer(&session, tracer);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Traces the stream chain `plan` (the JSON of `ide_streams::RealRunPlan`) while the program
|
||||
/// runs it, from `thread_id` stopped where the chain starts. Leaves the thread stopped right
|
||||
/// after the chain's terminal operation. `cancel` stops keeping records; the program runs on.
|
||||
pub async fn stream_trace(
|
||||
&self,
|
||||
s: DebugSessionId,
|
||||
thread_id: i64,
|
||||
plan: Value,
|
||||
cancel: ide_core::CancellationToken,
|
||||
progress: impl Fn(TraceProgress) + Send + Sync,
|
||||
) -> IdeResult<TraceRun> {
|
||||
let session = self.session(s)?;
|
||||
Ok(stream_trace::run(self, &session, thread_id, &plan, &cancel, &progress).await)
|
||||
}
|
||||
|
||||
/// Ends the running terminal operation by interrupting its thread, then by throwing into it.
|
||||
/// `None` when no trace runs.
|
||||
pub async fn stream_trace_abort(&self, s: DebugSessionId) -> IdeResult<Option<ide_jvm_inspect::AbortState>> {
|
||||
stream_trace::abort(&*self.session(s)?).await
|
||||
}
|
||||
|
||||
/// HotSwap: reloads the classes compiled since the session started (or since the
|
||||
/// last reload) into the debuggee (java-debug `redefineClasses`).
|
||||
pub async fn redefine_classes(&self, s: DebugSessionId) -> IdeResult<HotSwapResult> {
|
||||
|
||||
@@ -114,6 +114,10 @@ pub(crate) struct Session {
|
||||
pub jvm_located: watch::Sender<bool>,
|
||||
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
|
||||
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
|
||||
/// The last trace that finished, until the stop its records were read in ends.
|
||||
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
@@ -195,6 +199,13 @@ impl Suspension {
|
||||
self.0.lock().ticket
|
||||
}
|
||||
|
||||
/// The ticket of a stop of `thread` (its own or every thread's) taken after ticket `after`.
|
||||
pub fn stopped_since(&self, thread: i64, after: u64) -> Option<u64> {
|
||||
let stops = self.0.lock();
|
||||
let own = stops.threads.iter().find(|&&(id, _)| id == thread).map(|&(_, ticket)| ticket);
|
||||
own.max(stops.all).filter(|&ticket| ticket > after)
|
||||
}
|
||||
|
||||
/// After a successful resume-like request for `thread`; `all`: every thread ran.
|
||||
pub fn resumed(&self, ticket: u64, thread: i64, all: bool) {
|
||||
self.0.lock().release(Some(thread), all, ticket);
|
||||
@@ -270,6 +281,9 @@ impl Session {
|
||||
jvm_located: watch::channel(false).0,
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
stream_tracer: parking_lot::Mutex::new(None),
|
||||
stream_trace: parking_lot::Mutex::new(None),
|
||||
stream_trace_done: parking_lot::Mutex::new(None),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
@@ -741,6 +755,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
if crate::stream_trace::resume_traced_stop(s, int("threadId"), all) {
|
||||
return;
|
||||
}
|
||||
s.suspended.stopped(int("threadId"), all);
|
||||
let mut reason = str_("reason").unwrap_or_else(|| "pause".into());
|
||||
if let Some(quirks) = s.kotlin_lsp_quirks() {
|
||||
@@ -760,6 +777,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
// DAP: an event without the flag continues its thread alone. The UI keeps treating
|
||||
// it as all threads; the suspension, which holds only threads that stopped, need not.
|
||||
s.suspended.continued(int("threadId"), all.unwrap_or(false));
|
||||
crate::stream_trace::release_done(s);
|
||||
s.emit(DebugEvent::Continued {
|
||||
thread_id: int("threadId").unwrap_or(0),
|
||||
all_threads_continued: all.unwrap_or(true),
|
||||
|
||||
@@ -0,0 +1,433 @@
|
||||
//! A stream chain traced while the program itself runs it. The JDT LS bundle arms the trace with
|
||||
//! the thread stopped where the chain starts; the program runs on `continue`, and the bundle holds
|
||||
//! the thread inside the terminal operation once it has run, until a `stepOut` brings java-debug
|
||||
//! to a stop of its own in which the records are read.
|
||||
|
||||
use crate::jvm_memory::vm_target;
|
||||
use crate::session::Session;
|
||||
use crate::{DebugManager, StepKind};
|
||||
use ide_core::event::DebugEvent;
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use ide_jvm_inspect::{
|
||||
AbortState, InspectError, InspectFuture, StreamTracer, TraceCollected, TraceId, TraceState, VmTarget,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::future::Future;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Records the bundle keeps; later ones are only counted.
|
||||
const BUDGET: u32 = 50_000;
|
||||
const WAIT_MS: u32 = 500;
|
||||
const STOP_POLL: Duration = Duration::from_millis(20);
|
||||
const STOP_WAIT: Duration = Duration::from_secs(30);
|
||||
const RESUME_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
/// The bundle reaches the JVM through java-debug's own session.
|
||||
const ADAPTER: &str = "java-debug";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TraceProgress {
|
||||
pub phase: TracePhase,
|
||||
pub records: u64,
|
||||
pub dropped: u64,
|
||||
/// Since the program started running the chain, as the bundle measures it.
|
||||
pub elapsed_ms: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum TracePhase {
|
||||
Arming,
|
||||
Running,
|
||||
/// The terminal operation runs on, keeping no more records.
|
||||
RecordingStopped,
|
||||
Aborting,
|
||||
/// The terminal operation finished: stepping out of it and reading the records.
|
||||
Collecting,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum TraceRun {
|
||||
/// `generation`: the stop the records were read in, the only one their objects are valid in.
|
||||
Done {
|
||||
collected: TraceCollected,
|
||||
generation: u64,
|
||||
/// Stops of the traced thread while the program ran the chain, resumed unseen.
|
||||
resumed_stops: u32,
|
||||
},
|
||||
Unavailable {
|
||||
reason: TraceUnavailable,
|
||||
},
|
||||
Failed {
|
||||
detail: String,
|
||||
},
|
||||
/// Stop Recording or Abort Operation came before the terminal operation ran.
|
||||
Cancelled {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum TraceUnavailable {
|
||||
/// Not a java-debug session, or no JDT LS bundle behind it.
|
||||
NoBackend,
|
||||
NotSuspended,
|
||||
NotAtChainStart {
|
||||
detail: String,
|
||||
},
|
||||
/// A trace already runs in this session or its JVM.
|
||||
Busy,
|
||||
/// java-debug has no debug session for the JVM.
|
||||
NoSession,
|
||||
Unsupported {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
/// A trace that finished. Its records keep their objects from being collected until the stop they
|
||||
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
|
||||
pub(crate) struct DoneTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
target: VmTarget,
|
||||
id: TraceId,
|
||||
}
|
||||
|
||||
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
|
||||
pub(crate) fn release_done(s: &Session) {
|
||||
let Some(done) = s.stream_trace_done.lock().take() else { return };
|
||||
let ended = s.ended.clone();
|
||||
let session = s.id.0;
|
||||
tokio::spawn(async move {
|
||||
tokio::select! {
|
||||
biased;
|
||||
() = ended.cancelled() => {}
|
||||
result = done.tracer.release(&done.target, done.id) => {
|
||||
if let Err(e) = result {
|
||||
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// The session's running trace; `id` is `None` until `arm` answers.
|
||||
pub(crate) struct ActiveTrace {
|
||||
tracer: Arc<dyn StreamTracer>,
|
||||
target: VmTarget,
|
||||
id: Option<TraceId>,
|
||||
aborting: bool,
|
||||
thread_id: i64,
|
||||
/// From the `continue` that runs the chain until the bundle holds the thread after it.
|
||||
running: bool,
|
||||
resumed_stops: u32,
|
||||
}
|
||||
|
||||
/// A stop of the traced thread while the program runs the chain is resumed instead of shown, as
|
||||
/// IntelliJ does (spec G5): the UI keeps Resume locked meanwhile, and a breakpoint java-debug set
|
||||
/// since the bundle last switched them off, hit inside the terminal's invoke, would hold that
|
||||
/// invoke forever. java-debug stops a breakpoint's thread alone; a stop of every thread is shown.
|
||||
/// `true` when the stop was taken.
|
||||
pub(crate) fn resume_traced_stop(s: &Arc<Session>, thread_id: Option<i64>, all: bool) -> bool {
|
||||
let Some(thread_id) = thread_id.filter(|_| !all) else { return false };
|
||||
{
|
||||
let mut slot = s.stream_trace.lock();
|
||||
let Some(active) = slot.as_mut().filter(|a| a.running && a.thread_id == thread_id) else { return false };
|
||||
active.resumed_stops += 1;
|
||||
}
|
||||
let s = s.clone();
|
||||
tokio::spawn(async move {
|
||||
let sent =
|
||||
s.conn.request_timeout("continue", serde_json::json!({ "threadId": thread_id }), RESUME_TIMEOUT).await;
|
||||
if let Err(e) = sent {
|
||||
tracing::warn!(session = s.id.0, thread_id, "resuming a stop inside a stream trace: {e}");
|
||||
}
|
||||
});
|
||||
true
|
||||
}
|
||||
|
||||
fn set_running(s: &Session, running: bool) {
|
||||
if let Some(active) = s.stream_trace.lock().as_mut() {
|
||||
active.running = running;
|
||||
}
|
||||
}
|
||||
|
||||
/// Frees the session for the next trace however this one ends, a dropped future included.
|
||||
struct Claim<'s>(&'s Session);
|
||||
|
||||
impl Drop for Claim<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.stream_trace.lock().take();
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn set_tracer(s: &Session, tracer: Arc<dyn StreamTracer>) {
|
||||
*s.stream_tracer.lock() = Some(tracer);
|
||||
s.emit(DebugEvent::Capabilities);
|
||||
}
|
||||
|
||||
fn tracer(s: &Session) -> Option<Arc<dyn StreamTracer>> {
|
||||
s.stream_tracer.lock().clone().filter(|_| s.adapter == ADAPTER)
|
||||
}
|
||||
|
||||
pub(crate) fn available(s: &Session) -> bool {
|
||||
tracer(s).is_some()
|
||||
}
|
||||
|
||||
pub(crate) async fn run(
|
||||
mgr: &DebugManager,
|
||||
s: &Session,
|
||||
thread_id: i64,
|
||||
plan: &Value,
|
||||
cancel: &CancellationToken,
|
||||
progress: &(impl Fn(TraceProgress) + Send + Sync),
|
||||
) -> TraceRun {
|
||||
let unavailable = |reason| TraceRun::Unavailable { reason };
|
||||
let Some(tracer) = tracer(s) else { return unavailable(TraceUnavailable::NoBackend) };
|
||||
let target = vm_target(s);
|
||||
let _claim = {
|
||||
let mut slot = s.stream_trace.lock();
|
||||
if slot.is_some() {
|
||||
return unavailable(TraceUnavailable::Busy);
|
||||
}
|
||||
*slot = Some(ActiveTrace {
|
||||
tracer: tracer.clone(),
|
||||
target: target.clone(),
|
||||
id: None,
|
||||
aborting: false,
|
||||
thread_id,
|
||||
running: false,
|
||||
resumed_stops: 0,
|
||||
});
|
||||
Claim(s)
|
||||
};
|
||||
if !s.suspended.get() {
|
||||
return unavailable(TraceUnavailable::NotSuspended);
|
||||
}
|
||||
// The bundle releases the previous trace itself when this one arms.
|
||||
s.stream_trace_done.lock().take();
|
||||
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
|
||||
let token =
|
||||
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
|
||||
let mut trace = Trace {
|
||||
mgr,
|
||||
s,
|
||||
tracer: &*tracer,
|
||||
target: &target,
|
||||
thread_id,
|
||||
progress,
|
||||
token,
|
||||
arm_sent: false,
|
||||
id: None,
|
||||
last: Counts::default(),
|
||||
};
|
||||
match trace.drive(plan, cancel).await {
|
||||
Ok(run) => {
|
||||
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
|
||||
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
|
||||
}
|
||||
run
|
||||
}
|
||||
Err(run) => {
|
||||
// A stop from now on is the user's to see.
|
||||
set_running(s, false);
|
||||
trace.release().await;
|
||||
run
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `None` when no trace runs or it is still arming. The trace itself goes on to report how the
|
||||
/// abort ended it.
|
||||
pub(crate) async fn abort(s: &Session) -> IdeResult<Option<AbortState>> {
|
||||
let (tracer, target, id) = {
|
||||
let mut slot = s.stream_trace.lock();
|
||||
let Some(active) = slot.as_mut() else { return Ok(None) };
|
||||
let Some(id) = active.id else { return Ok(None) };
|
||||
active.aborting = true;
|
||||
(active.tracer.clone(), active.target.clone(), id)
|
||||
};
|
||||
let result = tokio::select! {
|
||||
biased;
|
||||
() = s.ended.cancelled() => return Ok(None),
|
||||
result = tracer.abort(&target, id) => result,
|
||||
};
|
||||
match result {
|
||||
Ok(state) => Ok(Some(state)),
|
||||
Err(InspectError::NoTrace) => Ok(None),
|
||||
Err(e) => Err(IdeError::internal(format!("cannot abort the stream trace: {e}"))),
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Counts {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
elapsed_ms: u64,
|
||||
}
|
||||
|
||||
struct Trace<'a, P> {
|
||||
mgr: &'a DebugManager,
|
||||
s: &'a Session,
|
||||
tracer: &'a dyn StreamTracer,
|
||||
/// The stop the trace was armed in.
|
||||
target: &'a VmTarget,
|
||||
thread_id: i64,
|
||||
progress: &'a P,
|
||||
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
|
||||
token: String,
|
||||
arm_sent: bool,
|
||||
/// Set once `arm` answers.
|
||||
id: Option<TraceId>,
|
||||
last: Counts,
|
||||
}
|
||||
|
||||
impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
|
||||
/// `Err` ends the trace early.
|
||||
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
|
||||
let (s, tracer, target) = (self.s, self.tracer, self.target);
|
||||
self.report(TracePhase::Arming);
|
||||
self.arm_sent = true;
|
||||
let id = self
|
||||
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
|
||||
.await?
|
||||
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
|
||||
self.id = Some(id);
|
||||
if let Some(active) = s.stream_trace.lock().as_mut() {
|
||||
active.id = Some(id);
|
||||
}
|
||||
// Before the request: the thread can stop again before its reply arrives.
|
||||
set_running(s, true);
|
||||
self.dap(self.mgr.resume(s.id, self.thread_id)).await?;
|
||||
let mut stopped = false;
|
||||
loop {
|
||||
if cancel.is_cancelled() && !stopped {
|
||||
stopped = true;
|
||||
// Refused when the trace parked or failed just before: `wait` reports that.
|
||||
match self.until_ended(tracer.stop(target, id)).await? {
|
||||
Ok(records) => {
|
||||
self.last.records = records;
|
||||
self.report(TracePhase::RecordingStopped);
|
||||
}
|
||||
Err(e) => tracing::debug!(session = s.id.0, trace = id, "stream trace stop: {e}"),
|
||||
}
|
||||
}
|
||||
match self.inspect(tracer.wait(target, id, WAIT_MS)).await? {
|
||||
TraceState::Running { records, dropped, elapsed_ms } => {
|
||||
self.last = Counts { records, dropped, elapsed_ms };
|
||||
let aborting = s.stream_trace.lock().as_ref().is_some_and(|a| a.aborting);
|
||||
self.report(if aborting {
|
||||
TracePhase::Aborting
|
||||
} else if stopped {
|
||||
TracePhase::RecordingStopped
|
||||
} else {
|
||||
TracePhase::Running
|
||||
});
|
||||
}
|
||||
TraceState::Parked { records, dropped } => {
|
||||
set_running(s, false);
|
||||
self.last.records = records;
|
||||
self.last.dropped = dropped;
|
||||
break;
|
||||
}
|
||||
TraceState::Failed { detail } => return Err(TraceRun::Failed { detail }),
|
||||
TraceState::Cancelled { detail } => return Err(TraceRun::Cancelled { detail }),
|
||||
}
|
||||
}
|
||||
self.report(TracePhase::Collecting);
|
||||
let before = s.suspended.ticket();
|
||||
self.dap(self.mgr.step(s.id, self.thread_id, StepKind::Out)).await?;
|
||||
// Another thread's stop meanwhile is not this one: the traced thread would still be
|
||||
// inside the terminal operation.
|
||||
let stop = async {
|
||||
loop {
|
||||
if let Some(ticket) = s.suspended.stopped_since(self.thread_id, before) {
|
||||
return ticket;
|
||||
}
|
||||
tokio::time::sleep(STOP_POLL).await;
|
||||
}
|
||||
};
|
||||
let Ok(generation) = self.until_ended(tokio::time::timeout(STOP_WAIT, stop)).await? else {
|
||||
// Collecting in the old stop would only be refused as stale.
|
||||
return Err(TraceRun::Failed { detail: step_out_timeout() });
|
||||
};
|
||||
let stopped_in = VmTarget { generation, ..vm_target(s) };
|
||||
let collected = self.inspect(tracer.collect(&stopped_in, id, self.last.records)).await?;
|
||||
let resumed_stops = s.stream_trace.lock().as_ref().map_or(0, |a| a.resumed_stops);
|
||||
Ok(TraceRun::Done { collected, generation, resumed_stops })
|
||||
}
|
||||
|
||||
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
|
||||
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
|
||||
/// undoes either, or does so once a terminal still running returns. Not after a finished
|
||||
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
|
||||
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
|
||||
/// by its token.
|
||||
async fn release(&self) {
|
||||
if self.s.ended.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
let work = match self.id {
|
||||
Some(id) => self.tracer.release(self.target, id),
|
||||
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
|
||||
None => return,
|
||||
};
|
||||
if let Ok(Err(e)) = self.until_ended(work).await {
|
||||
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
fn report(&self, phase: TracePhase) {
|
||||
let Counts { records, dropped, elapsed_ms } = self.last;
|
||||
(self.progress)(TraceProgress { phase, records, dropped, elapsed_ms });
|
||||
}
|
||||
|
||||
/// A reply may never come once the session ends.
|
||||
async fn until_ended<T>(&self, work: impl Future<Output = T>) -> Result<T, TraceRun> {
|
||||
tokio::select! {
|
||||
biased;
|
||||
() = self.s.ended.cancelled() => Err(ended()),
|
||||
value = work => Ok(value),
|
||||
}
|
||||
}
|
||||
|
||||
async fn inspect<T>(&self, work: InspectFuture<'_, T>) -> Result<T, TraceRun> {
|
||||
self.until_ended(work).await?.map_err(|e| self.failed(e.to_string()))
|
||||
}
|
||||
|
||||
async fn dap(&self, work: impl Future<Output = IdeResult<()>>) -> Result<(), TraceRun> {
|
||||
self.until_ended(work).await?.map_err(|e| self.failed(e.message))
|
||||
}
|
||||
|
||||
/// A request that failed because the session was ending says so.
|
||||
fn failed(&self, detail: String) -> TraceRun {
|
||||
if self.s.ended.is_cancelled() { ended() } else { TraceRun::Failed { detail } }
|
||||
}
|
||||
}
|
||||
|
||||
fn step_out_timeout() -> String {
|
||||
format!(
|
||||
"java-debug reported no stop within {} s of stepping out of the stream's terminal operation",
|
||||
STOP_WAIT.as_secs()
|
||||
)
|
||||
}
|
||||
|
||||
fn ended() -> TraceRun {
|
||||
TraceRun::Failed { detail: "the debug session ended".into() }
|
||||
}
|
||||
|
||||
fn refused(e: InspectError) -> TraceRun {
|
||||
use TraceUnavailable as U;
|
||||
let reason = match e {
|
||||
InspectError::NotSuspended => U::NotSuspended,
|
||||
InspectError::Busy => U::Busy,
|
||||
InspectError::NoSession => U::NoSession,
|
||||
InspectError::Unsupported(detail) => U::Unsupported { detail },
|
||||
InspectError::NotAtChainStart(detail) => U::NotAtChainStart { detail },
|
||||
other => return TraceRun::Failed { detail: other.to_string() },
|
||||
};
|
||||
TraceRun::Unavailable { reason }
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Protocol flow against an in-memory fake adapter.
|
||||
|
||||
mod jvm_inspect;
|
||||
mod stream_trace;
|
||||
|
||||
use super::*;
|
||||
use crate::adapter::{AdapterIo, LaunchFuture};
|
||||
@@ -71,10 +72,21 @@ async fn windows_stop_releases_the_debuggees_port_before_returning() {
|
||||
.unwrap();
|
||||
let pid = child.0.id();
|
||||
child.1 = Some(ide_core::process::ProcessTree::capture(pid));
|
||||
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate, ..Default::default() });
|
||||
// A running program: one suspended at a breakpoint is killed at once (#3658), without the
|
||||
// wait for its tree this test is about.
|
||||
let h = harness(Script {
|
||||
debuggee_pid: Some(pid),
|
||||
supports_terminate,
|
||||
continued_after_stop: true,
|
||||
..Default::default()
|
||||
});
|
||||
let id = h.start(config()).await.unwrap();
|
||||
let session = h.manager.session(id).unwrap();
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
|
||||
// The pid, then the stop at launch and the `continued` that ends it.
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid)
|
||||
|| session.suspended.ticket() == 0
|
||||
|| session.suspended.get()
|
||||
{
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
let stop = tokio::spawn({
|
||||
@@ -132,6 +144,16 @@ struct Script {
|
||||
continue_reply: Option<Value>,
|
||||
/// Answer `continue` and stop at a breakpoint again, instead of letting the program exit.
|
||||
stop_after_continue: bool,
|
||||
/// Answer `stepOut` and stop these threads one after the other, 100 ms apart (java-debug
|
||||
/// stops the stepping thread right after the call returns).
|
||||
step_out_stops: &'static [i64],
|
||||
/// Refuse `stepOut`.
|
||||
refuse_step_out: bool,
|
||||
/// Refuse `continue`.
|
||||
refuse_continue: bool,
|
||||
/// Stop thread 1 alone at a breakpoint right after each of the first this many `continue`s
|
||||
/// that `continue_reply` answers.
|
||||
breakpoints_after_continue: usize,
|
||||
/// The `reason` of the stop a `next` ends with (`step` when unset; kotlin-lsp says `breakpoint`).
|
||||
step_reason: Option<&'static str>,
|
||||
/// Refuse `next`, then stop at a breakpoint (one the program hit meanwhile).
|
||||
@@ -185,6 +207,10 @@ impl Default for Script {
|
||||
hang_up_after_stop: false,
|
||||
continue_reply: None,
|
||||
stop_after_continue: false,
|
||||
step_out_stops: &[],
|
||||
refuse_step_out: false,
|
||||
refuse_continue: false,
|
||||
breakpoints_after_continue: 0,
|
||||
step_reason: None,
|
||||
refuse_next: false,
|
||||
invalidated_after_stop: false,
|
||||
@@ -248,6 +274,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
let mut breakpoints_left = script.breakpoints_after_continue;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -494,7 +521,21 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
{"label": ""},
|
||||
]})
|
||||
),
|
||||
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
|
||||
"continue" if script.refuse_continue => send!(
|
||||
json!({"type": "response", "request_seq": msg["seq"], "command": "continue", "success": false, "message": "Thread is not suspended"})
|
||||
),
|
||||
"continue" if script.continue_reply.is_some() => {
|
||||
ok!(msg, script.continue_reply.clone().unwrap());
|
||||
if breakpoints_left > 0 {
|
||||
breakpoints_left -= 1;
|
||||
send!(
|
||||
json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1}})
|
||||
);
|
||||
}
|
||||
}
|
||||
"stepOut" if script.refuse_step_out => send!(
|
||||
json!({"type": "response", "request_seq": msg["seq"], "command": "stepOut", "success": false, "message": "Thread is not suspended"})
|
||||
),
|
||||
"continue" if script.stop_after_continue => {
|
||||
ok!(msg, json!({"allThreadsContinued": true}));
|
||||
send!(
|
||||
@@ -507,6 +548,16 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
send!(json!({"type": "event", "event": "terminated"}));
|
||||
}
|
||||
"pause" if script.hang_up_on_pause => break,
|
||||
"stepOut" if !script.step_out_stops.is_empty() => {
|
||||
ok!(msg, Value::Null);
|
||||
for (i, thread) in script.step_out_stops.iter().enumerate() {
|
||||
if i > 0 {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
let reason = if i + 1 == script.step_out_stops.len() { "step" } else { "breakpoint" };
|
||||
send!(json!({"type": "event", "event": "stopped", "body": {"reason": reason, "threadId": thread}}));
|
||||
}
|
||||
}
|
||||
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
|
||||
"redefineClasses" => {
|
||||
send!(
|
||||
@@ -1871,6 +1922,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: vec![],
|
||||
debugger: Some(ide_language::DebuggerConfig {
|
||||
|
||||
@@ -0,0 +1,558 @@
|
||||
//! A stream chain traced while the program runs it, through a session's stream tracer.
|
||||
|
||||
use super::*;
|
||||
use ide_core::CancellationToken;
|
||||
use ide_jvm_inspect::{
|
||||
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
|
||||
TraceState, VmTarget,
|
||||
};
|
||||
use std::collections::VecDeque;
|
||||
use tokio::sync::Notify;
|
||||
|
||||
const TRACE: TraceId = 7;
|
||||
|
||||
#[derive(Default)]
|
||||
struct FakeTracer {
|
||||
/// Answers to `wait`, in order. Once they run out, `wait` signals `waiting` and answers only
|
||||
/// after more are pushed and `more` is notified.
|
||||
waits: Mutex<VecDeque<Result<TraceState, InspectError>>>,
|
||||
arm_error: Mutex<Option<InspectError>>,
|
||||
stop_error: Mutex<Option<InspectError>>,
|
||||
collect_error: Mutex<Option<InspectError>>,
|
||||
/// The record count each `collect` was given.
|
||||
collect_records: Mutex<Vec<u64>>,
|
||||
calls: Mutex<Vec<(&'static str, VmTarget)>>,
|
||||
waiting: Notify,
|
||||
more: Notify,
|
||||
}
|
||||
|
||||
impl FakeTracer {
|
||||
fn scripted(waits: impl IntoIterator<Item = TraceState>) -> Arc<Self> {
|
||||
Self::answering(waits.into_iter().map(Ok))
|
||||
}
|
||||
|
||||
fn answering(waits: impl IntoIterator<Item = Result<TraceState, InspectError>>) -> Arc<Self> {
|
||||
Arc::new(Self { waits: Mutex::new(waits.into_iter().collect()), ..Self::default() })
|
||||
}
|
||||
|
||||
fn record(&self, name: &'static str, target: &VmTarget) {
|
||||
self.calls.lock().push((name, target.clone()));
|
||||
}
|
||||
|
||||
fn names(&self) -> Vec<&'static str> {
|
||||
self.calls.lock().iter().map(|(name, _)| *name).collect()
|
||||
}
|
||||
|
||||
fn target_of(&self, name: &str) -> VmTarget {
|
||||
self.calls.lock().iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone()).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
impl StreamTracer for FakeTracer {
|
||||
fn arm<'a>(
|
||||
&'a self,
|
||||
target: &'a VmTarget,
|
||||
_thread_id: i64,
|
||||
_plan: &'a Value,
|
||||
_budget: u32,
|
||||
_token: &'a str,
|
||||
) -> InspectFuture<'a, TraceId> {
|
||||
self.record("arm", target);
|
||||
let error = self.arm_error.lock().clone();
|
||||
Box::pin(async move { error.map_or(Ok(TRACE), Err) })
|
||||
}
|
||||
|
||||
fn wait<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, _ms: u32) -> InspectFuture<'a, TraceState> {
|
||||
self.record("wait", target);
|
||||
Box::pin(async move {
|
||||
loop {
|
||||
if let Some(state) = self.waits.lock().pop_front() {
|
||||
return state;
|
||||
}
|
||||
self.waiting.notify_one();
|
||||
self.more.notified().await;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn stop<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, u64> {
|
||||
self.record("stop", target);
|
||||
let error = self.stop_error.lock().clone();
|
||||
Box::pin(async move { error.map_or(Ok(3), Err) })
|
||||
}
|
||||
|
||||
fn abort<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, AbortState> {
|
||||
self.record("abort", target);
|
||||
Box::pin(async { Ok(AbortState::Interrupted) })
|
||||
}
|
||||
|
||||
fn collect<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
|
||||
self.record("collect", target);
|
||||
self.collect_records.lock().push(records);
|
||||
let error = self.collect_error.lock().clone();
|
||||
Box::pin(async move { error.map_or_else(|| Ok(collected()), Err) })
|
||||
}
|
||||
|
||||
fn release<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, ()> {
|
||||
self.record("release", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
|
||||
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
|
||||
self.record("releaseArmed", target);
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
}
|
||||
|
||||
fn collected() -> TraceCollected {
|
||||
TraceCollected {
|
||||
records: vec![(0, JvmValue::Primitive { type_name: "int".into(), text: "1".into() })],
|
||||
dropped: 0,
|
||||
terminal: CollectedTerminal::Void,
|
||||
skipped_breakpoints: 0,
|
||||
sequentialized: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn running(records: u64) -> TraceState {
|
||||
TraceState::Running { records, dropped: 0, elapsed_ms: 5 }
|
||||
}
|
||||
|
||||
fn parked() -> TraceState {
|
||||
TraceState::Parked { records: 10, dropped: 0 }
|
||||
}
|
||||
|
||||
/// java-debug keeps the program running after `continue` and stops right after a `stepOut`.
|
||||
fn java_debug() -> Script {
|
||||
Script { continue_reply: Some(json!({"allThreadsContinued": true})), step_out_stops: &[1], ..Script::default() }
|
||||
}
|
||||
|
||||
async fn stopped_java(h: &Harness, tracer: &Arc<FakeTracer>) -> DebugSessionId {
|
||||
let id = h.start(java_config("launch")).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
h.manager.set_stream_tracer(id, tracer.clone()).unwrap();
|
||||
id
|
||||
}
|
||||
|
||||
async fn trace(h: &Harness, id: DebugSessionId) -> IdeResult<TraceRun> {
|
||||
let run = h.manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), |_| {});
|
||||
tokio::time::timeout(Duration::from_secs(10), run).await.expect("the trace did not end")
|
||||
}
|
||||
|
||||
/// A trace in its own task, returned once it waits for the answers its tracer has not got.
|
||||
async fn hanging_trace(
|
||||
h: &Harness,
|
||||
id: DebugSessionId,
|
||||
tracer: &FakeTracer,
|
||||
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
|
||||
hanging_trace_with(h, id, tracer, |_| {}).await
|
||||
}
|
||||
|
||||
async fn hanging_trace_with(
|
||||
h: &Harness,
|
||||
id: DebugSessionId,
|
||||
tracer: &FakeTracer,
|
||||
progress: impl Fn(TraceProgress) + Send + Sync + 'static,
|
||||
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
|
||||
let manager = h.manager.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), progress).await
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(5), tracer.waiting.notified()).await.expect("the trace did not wait");
|
||||
task
|
||||
}
|
||||
|
||||
fn phases(seen: &Mutex<Vec<TraceProgress>>) -> Vec<TracePhase> {
|
||||
seen.lock().iter().map(|p| p.phase).collect()
|
||||
}
|
||||
|
||||
fn progress(phase: TracePhase, records: u64, elapsed_ms: u64) -> TraceProgress {
|
||||
TraceProgress { phase, records, dropped: 0, elapsed_ms }
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_runs_continue_then_step_out() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let start = h.manager.session(id).unwrap().suspended.ticket();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
let TraceRun::Done { collected: got, generation, resumed_stops } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(got, collected());
|
||||
assert_eq!(resumed_stops, 0);
|
||||
assert!(generation > start, "collected in the stop of the trace ({start}), not after it ({generation})");
|
||||
let commands = h.commands();
|
||||
let resumed = commands.iter().position(|c| c == "continue").expect("no continue");
|
||||
let stepped = commands.iter().position(|c| c == "stepOut").expect("no stepOut");
|
||||
assert!(resumed < stepped, "{commands:?}");
|
||||
assert_eq!(h.request("continue")["arguments"]["threadId"], 1);
|
||||
assert_eq!(h.request("stepOut")["arguments"]["threadId"], 1);
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "collect"]);
|
||||
assert_eq!(*tracer.collect_records.lock(), [10], "collect is told how many records the trace parked with");
|
||||
assert_eq!(tracer.target_of("arm").generation, start);
|
||||
assert_eq!(tracer.target_of("collect").generation, generation);
|
||||
assert!(h.manager.session(id).unwrap().suspended.get());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_reports_progress() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), move |p| sink.lock().push(p)).await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(
|
||||
*seen.lock(),
|
||||
[
|
||||
progress(TracePhase::Arming, 0, 0),
|
||||
progress(TracePhase::Running, 10, 5),
|
||||
progress(TracePhase::Collecting, 10, 5),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancel_stops_recording_once() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), running(12), parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let cancel = CancellationToken::new();
|
||||
let on_running = cancel.clone();
|
||||
let seen: Arc<Mutex<Vec<TracePhase>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h
|
||||
.manager
|
||||
.stream_trace(id, 1, json!({}), cancel, move |p| {
|
||||
if p.phase == TracePhase::Running {
|
||||
on_running.cancel();
|
||||
}
|
||||
sink.lock().push(p.phase);
|
||||
})
|
||||
.await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "wait", "collect"]);
|
||||
assert_eq!(
|
||||
*seen.lock(),
|
||||
[
|
||||
TracePhase::Arming,
|
||||
TracePhase::Running,
|
||||
TracePhase::RecordingStopped,
|
||||
TracePhase::RecordingStopped,
|
||||
TracePhase::Collecting
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn second_trace_is_busy() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let first = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
let second = trace(&h, id).await.unwrap();
|
||||
|
||||
assert_eq!(second, TraceRun::Unavailable { reason: TraceUnavailable::Busy });
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 1);
|
||||
first.abort();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn trace_ends_when_session_ends() {
|
||||
// The fake adapter lets the program exit on `continue`.
|
||||
let h = harness(Script::default());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let session = h.manager.session(id).unwrap();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert_eq!(run, TraceRun::Failed { detail: "the debug session ended".into() });
|
||||
assert!(session.stream_trace.lock().is_none());
|
||||
let next = trace(&h, id).await;
|
||||
assert!(!matches!(next, Ok(TraceRun::Unavailable { reason: TraceUnavailable::Busy })), "{next:?}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dropping_the_trace_frees_the_session() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let first = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
first.abort();
|
||||
assert!(first.await.unwrap_err().is_cancelled());
|
||||
|
||||
let session = h.manager.session(id).unwrap();
|
||||
assert!(session.stream_trace.lock().is_none());
|
||||
// The first trace resumed the thread.
|
||||
session.suspended.stopped(Some(1), false);
|
||||
let again = hanging_trace(&h, id, &tracer).await;
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 2);
|
||||
again.abort();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn arm_errors_map_to_unavailable_or_failed() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
*tracer.arm_error.lock() = Some(InspectError::NotAtChainStart("the stop is on line 4".into()));
|
||||
assert_eq!(
|
||||
trace(&h, id).await.unwrap(),
|
||||
TraceRun::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "the stop is on line 4".into() } }
|
||||
);
|
||||
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
|
||||
assert!(!h.commands().iter().any(|c| c == "continue"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn abort_reaches_the_running_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), None);
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
let task = hanging_trace_with(&h, id, &tracer, move |p| sink.lock().push(p)).await;
|
||||
|
||||
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), Some(AbortState::Interrupted));
|
||||
assert_eq!(tracer.target_of("abort"), tracer.target_of("arm"));
|
||||
|
||||
let thrown = "java.lang.RuntimeException: oi-cancel:1";
|
||||
tracer.waits.lock().extend([Ok(running(4)), Ok(TraceState::Failed { detail: thrown.into() })]);
|
||||
tracer.more.notify_one();
|
||||
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
|
||||
assert_eq!(run, TraceRun::Failed { detail: thrown.into() });
|
||||
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Aborting]);
|
||||
assert_eq!(tracer.names().last(), Some(&"release"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn failed_wait_passes_its_detail_through() {
|
||||
let h = harness(java_debug());
|
||||
let detail = "the program began to exit while the stream ran: stop the debug session";
|
||||
let tracer = FakeTracer::scripted([running(1), TraceState::Failed { detail: detail.into() }]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: detail.into() });
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
|
||||
assert!(!h.commands().iter().any(|c| c == "stepOut"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_trace_cancelled_before_its_terminal_says_so() {
|
||||
let detail = "cancelled before the terminal ran";
|
||||
let tracer = FakeTracer::scripted([TraceState::Cancelled { detail: detail.into() }]);
|
||||
let h = harness(java_debug());
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Cancelled { detail: detail.into() });
|
||||
assert!(!h.commands().iter().any(|c| c == "stepOut"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_wait_that_errs_releases_the_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::answering([Ok(running(1)), Err(InspectError::TimedOut)]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
|
||||
assert_eq!(tracer.target_of("release"), tracer.target_of("arm"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_refused_step_out_releases_the_trace() {
|
||||
let h = harness(Script { refuse_step_out: true, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert!(matches!(&run, TraceRun::Failed { detail } if detail.contains("not suspended")), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_refused_continue_releases_the_trace() {
|
||||
let h = harness(Script { refuse_continue: true, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
assert!(matches!(&run, TraceRun::Failed { .. }), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_failed_collect_releases_the_trace() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
*tracer.collect_error.lock() = Some(InspectError::Stale);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "collect", "release"]);
|
||||
}
|
||||
|
||||
fn stops(h: &Harness) -> usize {
|
||||
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Stopped { .. }, .. })).count()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_stop_of_the_traced_thread_while_the_chain_runs_is_resumed_unseen() {
|
||||
// A breakpoint java-debug set meanwhile, hit inside the terminal's invoke before the bundle
|
||||
// switched it off: held there, the invoke would never return.
|
||||
let h = harness(Script { breakpoints_after_continue: 1, ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let shown = stops(&h);
|
||||
let task = hanging_trace(&h, id, &tracer).await;
|
||||
|
||||
for _ in 0..200 {
|
||||
if h.commands().iter().filter(|c| *c == "continue").count() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(h.commands().iter().filter(|c| *c == "continue").count(), 2, "{:?}", h.commands());
|
||||
assert_eq!(h.log.lock().iter().rfind(|m| m["command"] == "continue").unwrap()["arguments"]["threadId"], 1);
|
||||
tracer.waits.lock().push_back(Ok(parked()));
|
||||
tracer.more.notify_one();
|
||||
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
|
||||
|
||||
let TraceRun::Done { resumed_stops, .. } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(resumed_stops, 1);
|
||||
assert_eq!(stops(&h), shown + 1, "only the step-out stop is shown, after the trace parked");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_finished_trace_is_not_released() {
|
||||
// Releasing unpins the records, which the result's values still show until the program runs on.
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
|
||||
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_finished_trace_is_released_once_the_program_runs_on() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
|
||||
|
||||
h.manager.resume(id, 1).await.unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !tracer.names().contains(&"release") {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("the finished trace was not released");
|
||||
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_arm_without_a_reply_is_released_by_its_token() {
|
||||
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
|
||||
|
||||
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
|
||||
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn refused_stop_leaves_the_outcome_to_wait() {
|
||||
let h = harness(java_debug());
|
||||
let tracer = FakeTracer::scripted([running(10), parked()]);
|
||||
*tracer.stop_error.lock() = Some(InspectError::NoTrace);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let cancel = CancellationToken::new();
|
||||
let on_running = cancel.clone();
|
||||
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
|
||||
let sink = seen.clone();
|
||||
|
||||
let run = h
|
||||
.manager
|
||||
.stream_trace(id, 1, json!({}), cancel, move |p| {
|
||||
if p.phase == TracePhase::Running {
|
||||
on_running.cancel();
|
||||
}
|
||||
sink.lock().push(p);
|
||||
})
|
||||
.await;
|
||||
|
||||
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "collect"]);
|
||||
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Running, TracePhase::Collecting]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn another_threads_stop_is_not_the_step_out() {
|
||||
// Thread 2 stops at a breakpoint 100 ms before the traced thread's step out ends.
|
||||
let h = harness(Script { step_out_stops: &[2, 1], ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
let start = h.manager.session(id).unwrap().suspended.ticket();
|
||||
|
||||
let run = trace(&h, id).await.unwrap();
|
||||
|
||||
let TraceRun::Done { generation, .. } = run else { panic!("not done: {run:?}") };
|
||||
assert_eq!(
|
||||
generation,
|
||||
start + 2,
|
||||
"collected in thread 2's stop, not in the traced thread's step-out stop after it"
|
||||
);
|
||||
assert_eq!(tracer.target_of("collect").generation, generation);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn step_out_without_a_stop_times_out() {
|
||||
let h = harness(Script { step_out_stops: &[], ..java_debug() });
|
||||
let tracer = FakeTracer::scripted([parked()]);
|
||||
let id = stopped_java(&h, &tracer).await;
|
||||
tokio::time::pause();
|
||||
|
||||
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), |_| {}).await.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
run,
|
||||
TraceRun::Failed {
|
||||
detail: "java-debug reported no stop within 30 s of stepping out of the stream's terminal operation".into()
|
||||
}
|
||||
);
|
||||
assert!(h.commands().iter().any(|c| c == "stepOut"));
|
||||
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn capability_only_for_java_debug() {
|
||||
let h = harness(Script::default());
|
||||
let tracer = FakeTracer::scripted([]);
|
||||
let java = h.start(java_config("launch")).await.unwrap();
|
||||
assert!(!h.manager.capabilities(java).unwrap().stream_trace);
|
||||
h.manager.set_stream_tracer(java, tracer.clone()).unwrap();
|
||||
assert!(h.manager.capabilities(java).unwrap().stream_trace);
|
||||
|
||||
let other = h.start(config()).await.unwrap();
|
||||
h.manager.set_stream_tracer(other, tracer.clone()).unwrap();
|
||||
assert!(!h.manager.capabilities(other).unwrap().stream_trace);
|
||||
}
|
||||
@@ -14,6 +14,7 @@ mod snowflake;
|
||||
pub mod source;
|
||||
pub mod split;
|
||||
pub mod sql;
|
||||
pub mod tools;
|
||||
mod watch;
|
||||
pub use watch::SourcesWatch;
|
||||
|
||||
@@ -787,6 +788,56 @@ impl DbManager {
|
||||
Ok(v.unwrap_or_else(|| "Connected".into()))
|
||||
}
|
||||
|
||||
/// Runs `job` with the client tool at `executable` against target `id`, connected like the
|
||||
/// data source (through its SSH tunnel, with its SSL settings and password), until it exits
|
||||
/// or `cancel` fires. Connects first, so a missing password fails the way it does for a
|
||||
/// console. Returns the exit code.
|
||||
pub async fn run_tool(
|
||||
&self,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &tools::DbToolJob,
|
||||
cancel: &CancellationToken,
|
||||
on_output: impl FnMut(Vec<tools::ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let tool = job.tool();
|
||||
if !tool.is_program(executable) {
|
||||
return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program())));
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
if source.driver != tool.driver() {
|
||||
return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name)));
|
||||
}
|
||||
self.pool(id).await?;
|
||||
let password = self.password(&source).await;
|
||||
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
|
||||
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
|
||||
let prepared = tools::prepare(job, &target, password.as_deref());
|
||||
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
|
||||
}
|
||||
|
||||
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
|
||||
/// own host and port (not a tunnel's local end), and no password.
|
||||
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
|
||||
let source = self.source(id)?;
|
||||
let prepared = tools::prepare(job, &source, None);
|
||||
Ok(tools::command_line(executable, &prepared.args))
|
||||
}
|
||||
|
||||
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
|
||||
pub async fn server_version(&self, id: &str) -> IdeResult<u32> {
|
||||
let pool = self.pool(id).await?;
|
||||
if pool.driver() != DbDriver::Postgres {
|
||||
return Err(IdeError::invalid("not a PostgreSQL data source"));
|
||||
}
|
||||
let rows = pool.rows("SHOW server_version_num", 1).await?;
|
||||
rows.into_iter()
|
||||
.next()
|
||||
.and_then(|r| r.into_iter().next().flatten())
|
||||
.and_then(|v| v.trim().parse().ok())
|
||||
.ok_or_else(|| IdeError::internal("no server version"))
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().contains_key(id)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,341 @@
|
||||
//! What a dump or restore dialog asks for, as typed options, and the arguments that do it.
|
||||
//! The connection arguments come from [`super::connection`]; these are the rest.
|
||||
|
||||
use super::DbTool;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpFormat {
|
||||
/// SQL text, restored with `psql`.
|
||||
Plain,
|
||||
Custom,
|
||||
/// A directory of files; the only format `pg_dump` writes in parallel.
|
||||
Directory,
|
||||
Tar,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpStatements {
|
||||
Copy,
|
||||
Inserts,
|
||||
ColumnInserts,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpContent {
|
||||
All,
|
||||
SchemaOnly,
|
||||
DataOnly,
|
||||
}
|
||||
|
||||
/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names).
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPgDumpOptions {
|
||||
pub format: DbDumpFormat,
|
||||
pub statements: DbDumpStatements,
|
||||
pub content: DbDumpContent,
|
||||
pub schemas: Vec<String>,
|
||||
pub tables: Vec<String>,
|
||||
pub exclude_tables: Vec<String>,
|
||||
/// Plain format only: archives get DROP / CREATE at restore.
|
||||
pub clean: bool,
|
||||
pub if_exists: bool,
|
||||
pub create: bool,
|
||||
pub no_owner: bool,
|
||||
pub no_privileges: bool,
|
||||
/// Directory format only.
|
||||
pub jobs: u32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPgRestoreOptions {
|
||||
pub content: DbDumpContent,
|
||||
pub schemas: Vec<String>,
|
||||
pub clean: bool,
|
||||
pub if_exists: bool,
|
||||
pub no_owner: bool,
|
||||
pub no_privileges: bool,
|
||||
pub single_transaction: bool,
|
||||
pub exit_on_error: bool,
|
||||
/// Ignored with a single transaction, which `pg_restore` cannot split.
|
||||
pub jobs: u32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct DbPsqlOptions {
|
||||
pub single_transaction: bool,
|
||||
pub stop_on_error: bool,
|
||||
}
|
||||
|
||||
/// A run of a client tool: which one, the file it writes or reads, and its options.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "tool", rename_all = "camelCase")]
|
||||
pub enum DbToolJob {
|
||||
PgDump {
|
||||
file: String,
|
||||
options: DbPgDumpOptions,
|
||||
},
|
||||
/// `file`: an archive, or a directory archive.
|
||||
PgRestore {
|
||||
file: String,
|
||||
options: DbPgRestoreOptions,
|
||||
},
|
||||
Psql {
|
||||
file: String,
|
||||
options: DbPsqlOptions,
|
||||
},
|
||||
}
|
||||
|
||||
impl DbToolJob {
|
||||
pub fn tool(&self) -> DbTool {
|
||||
match self {
|
||||
DbToolJob::PgDump { .. } => DbTool::PgDump,
|
||||
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
|
||||
DbToolJob::Psql { .. } => DbTool::Psql,
|
||||
}
|
||||
}
|
||||
|
||||
/// The arguments after the connection ones.
|
||||
pub fn args(&self) -> Vec<String> {
|
||||
match self {
|
||||
DbToolJob::PgDump { file, options } => pg_dump(options, file),
|
||||
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
|
||||
DbToolJob::Psql { file, options } => psql(options, file),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn flag(on: bool, flag: &str) -> Option<String> {
|
||||
on.then(|| flag.to_owned())
|
||||
}
|
||||
|
||||
fn content(c: DbDumpContent) -> Option<String> {
|
||||
match c {
|
||||
DbDumpContent::All => None,
|
||||
DbDumpContent::SchemaOnly => Some("--schema-only".into()),
|
||||
DbDumpContent::DataOnly => Some("--data-only".into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn each(names: &[String], option: &str) -> impl Iterator<Item = String> {
|
||||
names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}"))
|
||||
}
|
||||
|
||||
fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
|
||||
let plain = o.format == DbDumpFormat::Plain;
|
||||
let format = match o.format {
|
||||
DbDumpFormat::Plain => "p",
|
||||
DbDumpFormat::Custom => "c",
|
||||
DbDumpFormat::Directory => "d",
|
||||
DbDumpFormat::Tar => "t",
|
||||
};
|
||||
let mut args = vec![format!("--format={format}"), format!("--file={file}")];
|
||||
args.extend(match o.statements {
|
||||
DbDumpStatements::Copy => None,
|
||||
DbDumpStatements::Inserts => Some("--inserts".to_owned()),
|
||||
DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()),
|
||||
});
|
||||
args.extend(content(o.content));
|
||||
args.extend(each(&o.schemas, "schema"));
|
||||
args.extend(each(&o.tables, "table"));
|
||||
args.extend(each(&o.exclude_tables, "exclude-table"));
|
||||
args.extend(flag(plain && o.clean, "--clean"));
|
||||
args.extend(flag(plain && o.clean && o.if_exists, "--if-exists"));
|
||||
args.extend(flag(plain && o.create, "--create"));
|
||||
args.extend(flag(o.no_owner, "--no-owner"));
|
||||
args.extend(flag(o.no_privileges, "--no-privileges"));
|
||||
if o.format == DbDumpFormat::Directory && o.jobs > 1 {
|
||||
args.push(format!("--jobs={}", o.jobs));
|
||||
}
|
||||
args.push("--verbose".into());
|
||||
args
|
||||
}
|
||||
|
||||
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
|
||||
let mut args: Vec<String> = content(o.content).into_iter().collect();
|
||||
args.extend(each(&o.schemas, "schema"));
|
||||
args.extend(flag(o.clean, "--clean"));
|
||||
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
|
||||
args.extend(flag(o.no_owner, "--no-owner"));
|
||||
args.extend(flag(o.no_privileges, "--no-privileges"));
|
||||
args.extend(flag(o.single_transaction, "--single-transaction"));
|
||||
args.extend(flag(o.exit_on_error, "--exit-on-error"));
|
||||
if o.jobs > 1 && !o.single_transaction {
|
||||
args.push(format!("--jobs={}", o.jobs));
|
||||
}
|
||||
args.push("--verbose".into());
|
||||
if !file.is_empty() {
|
||||
args.push(file.to_owned());
|
||||
}
|
||||
args
|
||||
}
|
||||
|
||||
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
|
||||
// `~/.psqlrc` could switch databases or change settings before the dump runs.
|
||||
let mut args = vec!["--no-psqlrc".to_owned()];
|
||||
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
|
||||
args.extend(flag(o.single_transaction, "--single-transaction"));
|
||||
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
|
||||
args
|
||||
}
|
||||
|
||||
/// The command as a shell would need it typed: the dialogs' preview.
|
||||
pub fn command_line(program: &Path, args: &[String]) -> String {
|
||||
let quote = |s: &str| {
|
||||
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
|
||||
s.to_owned()
|
||||
} else {
|
||||
format!("'{}'", s.replace('\'', "'\\''"))
|
||||
}
|
||||
};
|
||||
std::iter::once(program.to_string_lossy().into_owned())
|
||||
.chain(args.iter().cloned())
|
||||
.map(|a| quote(&a))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn dump() -> DbPgDumpOptions {
|
||||
DbPgDumpOptions {
|
||||
format: DbDumpFormat::Plain,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
}
|
||||
}
|
||||
|
||||
fn restore() -> DbPgRestoreOptions {
|
||||
DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
single_transaction: false,
|
||||
exit_on_error: true,
|
||||
jobs: 1,
|
||||
}
|
||||
}
|
||||
|
||||
fn args(job: DbToolJob) -> Vec<String> {
|
||||
job.args()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dumps_plain_sql_with_copy_by_default() {
|
||||
let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() };
|
||||
assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn turns_lists_and_switches_into_flags() {
|
||||
let options = DbPgDumpOptions {
|
||||
statements: DbDumpStatements::ColumnInserts,
|
||||
content: DbDumpContent::DataOnly,
|
||||
schemas: vec!["public".into(), "audit".into()],
|
||||
tables: vec!["public.orders".into()],
|
||||
exclude_tables: vec!["public.log_*".into()],
|
||||
clean: true,
|
||||
if_exists: true,
|
||||
create: true,
|
||||
no_owner: true,
|
||||
..dump()
|
||||
};
|
||||
assert_eq!(
|
||||
args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }),
|
||||
[
|
||||
"--format=p",
|
||||
"--file=/tmp/x.sql",
|
||||
"--column-inserts",
|
||||
"--data-only",
|
||||
"--schema=public",
|
||||
"--schema=audit",
|
||||
"--table=public.orders",
|
||||
"--exclude-table=public.log_*",
|
||||
"--clean",
|
||||
"--if-exists",
|
||||
"--create",
|
||||
"--no-owner",
|
||||
"--verbose",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leaves_drop_and_create_to_the_restore_of_an_archive() {
|
||||
let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() };
|
||||
let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options });
|
||||
assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_parallel_jobs_only_where_the_tool_can() {
|
||||
let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() };
|
||||
assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into()));
|
||||
let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir };
|
||||
assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into()));
|
||||
let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() };
|
||||
let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single });
|
||||
assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restores_the_archive_named_last_and_stops_on_the_first_error() {
|
||||
assert_eq!(
|
||||
args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }),
|
||||
["--exit-on-error", "--verbose", "/tmp/shop.dump"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn leaves_out_an_archive_not_chosen_yet() {
|
||||
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
|
||||
assert_eq!(a, ["--exit-on-error", "--verbose"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runs_a_sql_file_in_one_transaction_that_stops_on_error() {
|
||||
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
|
||||
assert_eq!(
|
||||
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
|
||||
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn quotes_what_a_shell_would_split() {
|
||||
let line = command_line(
|
||||
Path::new("/usr/bin/pg_dump"),
|
||||
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
|
||||
);
|
||||
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_the_job_the_dialog_sends() {
|
||||
let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#;
|
||||
let job: DbToolJob = serde_json::from_str(json).unwrap();
|
||||
assert_eq!(job.tool(), DbTool::Psql);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,558 @@
|
||||
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
|
||||
//! arguments and environment that connect them like the data source, and running them.
|
||||
|
||||
mod jobs;
|
||||
pub use jobs::*;
|
||||
|
||||
use crate::source::{DataSource, DbDriver, DbSslMode};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::ffi::OsStr;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbTool {
|
||||
PgDump,
|
||||
PgRestore,
|
||||
Psql,
|
||||
}
|
||||
|
||||
impl DbTool {
|
||||
pub fn program(self) -> &'static str {
|
||||
self.programs()[0]
|
||||
}
|
||||
|
||||
/// Executable names.
|
||||
pub fn programs(self) -> &'static [&'static str] {
|
||||
match self {
|
||||
DbTool::PgDump => &["pg_dump"],
|
||||
DbTool::PgRestore => &["pg_restore"],
|
||||
DbTool::Psql => &["psql"],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn driver(self) -> DbDriver {
|
||||
DbDriver::Postgres
|
||||
}
|
||||
|
||||
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
|
||||
/// The data source's password is handed only to such a program.
|
||||
pub fn is_program(self, path: &Path) -> bool {
|
||||
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
|
||||
self.programs().iter().any(|p| {
|
||||
stem.strip_prefix(p).is_some_and(|rest| {
|
||||
let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest);
|
||||
digits.chars().all(|c| c.is_ascii_digit())
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// An installed copy of a tool.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
|
||||
pub struct ToolInstall {
|
||||
pub path: String,
|
||||
/// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`.
|
||||
pub version: String,
|
||||
}
|
||||
|
||||
/// A line the tool wrote.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase", rename = "DbToolLine")]
|
||||
pub struct ToolLine {
|
||||
pub stderr: bool,
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
/// Directories holding the tools that are often missing from `PATH`, by platform.
|
||||
fn known_dirs() -> Vec<PathBuf> {
|
||||
let mut dirs = Vec::new();
|
||||
if cfg!(target_os = "macos") {
|
||||
for prefix in ["/opt/homebrew", "/usr/local"] {
|
||||
dirs.push(PathBuf::from(format!("{prefix}/bin")));
|
||||
let opt = PathBuf::from(format!("{prefix}/opt"));
|
||||
for keg in ["libpq", "postgresql"] {
|
||||
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
dirs.extend(
|
||||
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
|
||||
);
|
||||
} else if cfg!(windows) {
|
||||
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
|
||||
if let Some(base) = std::env::var_os(var) {
|
||||
let root = PathBuf::from(base).join("PostgreSQL");
|
||||
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
|
||||
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
|
||||
}
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Subdirectories of `parent` whose name starts with `prefix`, newest version first.
|
||||
fn children(parent: &Path, prefix: &str) -> Vec<PathBuf> {
|
||||
let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() };
|
||||
let mut dirs: Vec<PathBuf> = entries
|
||||
.flatten()
|
||||
.filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix)))
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.is_dir())
|
||||
.collect();
|
||||
dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy())));
|
||||
dirs
|
||||
}
|
||||
|
||||
/// The numbers in `text`, for comparing versions (`17.2` after `9.6`).
|
||||
fn version_key(text: &str) -> Vec<u32> {
|
||||
text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect()
|
||||
}
|
||||
|
||||
/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first.
|
||||
/// Blocking: runs each one's `--version`.
|
||||
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
|
||||
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
|
||||
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
|
||||
dirs.extend(known_dirs());
|
||||
let mut seen = Vec::new();
|
||||
let mut out = Vec::new();
|
||||
for dir in dirs {
|
||||
for program in tool.programs() {
|
||||
let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue };
|
||||
let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone());
|
||||
if seen.contains(&real) {
|
||||
continue;
|
||||
}
|
||||
seen.push(real);
|
||||
if let Ok(version) = version_of(&found) {
|
||||
out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version });
|
||||
}
|
||||
}
|
||||
}
|
||||
out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version)));
|
||||
out
|
||||
}
|
||||
|
||||
/// The first line `path --version` prints. Blocking.
|
||||
pub fn version_of(path: &Path) -> IdeResult<String> {
|
||||
let (ok, text) = capture(path, "--version")?;
|
||||
match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) {
|
||||
Some(line) if ok => Ok(line.to_owned()),
|
||||
_ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
|
||||
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
|
||||
if !path.is_file() {
|
||||
return Err(IdeError::not_found(format!("{} does not exist", path.display())));
|
||||
}
|
||||
let mut cmd = std::process::Command::new(path);
|
||||
cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
|
||||
ide_core::process::prepare(&mut cmd);
|
||||
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?;
|
||||
let mut stdout = child.stdout.take().expect("piped");
|
||||
let reader = std::thread::spawn(move || {
|
||||
let mut buf = Vec::new();
|
||||
let _ = std::io::Read::read_to_end(&mut stdout, &mut buf);
|
||||
buf
|
||||
});
|
||||
let deadline = std::time::Instant::now() + Duration::from_secs(5);
|
||||
let status = loop {
|
||||
if let Some(status) = child.try_wait()? {
|
||||
break status;
|
||||
}
|
||||
if std::time::Instant::now() > deadline {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display())));
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
};
|
||||
let out = reader.join().unwrap_or_default();
|
||||
Ok((status.success(), String::from_utf8_lossy(&out).into_owned()))
|
||||
}
|
||||
|
||||
/// What made a dump, read from its first bytes (a directory: its `toc.dat`).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum DbDumpKind {
|
||||
/// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`.
|
||||
PostgresArchive,
|
||||
/// Plain SQL from `pg_dump`: `psql`.
|
||||
PostgresSql,
|
||||
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
|
||||
MysqlSql,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
/// Blocking: reads at most the first 4 KiB.
|
||||
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
|
||||
use std::io::Read;
|
||||
if path.is_dir() {
|
||||
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
|
||||
}
|
||||
let mut head = Vec::with_capacity(4096);
|
||||
std::fs::File::open(path)
|
||||
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
|
||||
.take(4096)
|
||||
.read_to_end(&mut head)?;
|
||||
Ok(kind_of(&head))
|
||||
}
|
||||
|
||||
fn kind_of(head: &[u8]) -> DbDumpKind {
|
||||
// A tar archive keeps `toc.dat` first; its name starts the 512-byte header.
|
||||
if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") {
|
||||
return DbDumpKind::PostgresArchive;
|
||||
}
|
||||
let text = String::from_utf8_lossy(head);
|
||||
let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect();
|
||||
if comments.iter().any(|l| l.contains("PostgreSQL database dump")) {
|
||||
DbDumpKind::PostgresSql
|
||||
} else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) {
|
||||
DbDumpKind::MysqlSql
|
||||
} else {
|
||||
DbDumpKind::Unknown
|
||||
}
|
||||
}
|
||||
|
||||
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
|
||||
/// tunnel when it has one). The password is left to [`prepare`].
|
||||
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
|
||||
let mut args = Vec::new();
|
||||
let host = source.host.trim();
|
||||
if !host.is_empty() {
|
||||
args.push(format!("--host={host}"));
|
||||
}
|
||||
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432)));
|
||||
if !source.user.trim().is_empty() {
|
||||
args.push(format!("--username={}", source.user.trim()));
|
||||
}
|
||||
if !source.database.is_empty() {
|
||||
args.push(format!("--dbname={}", dbname_arg(&source.database)));
|
||||
}
|
||||
// Without a terminal a password prompt would wait forever: fail instead.
|
||||
args.push("--no-password".into());
|
||||
|
||||
let mut env = vec![
|
||||
("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())),
|
||||
(
|
||||
"PGSSLMODE".to_owned(),
|
||||
match source.ssl {
|
||||
DbSslMode::Disable => "disable",
|
||||
DbSslMode::Prefer => "prefer",
|
||||
DbSslMode::Require => "require",
|
||||
DbSslMode::VerifyCa => "verify-ca",
|
||||
DbSslMode::VerifyFull => "verify-full",
|
||||
}
|
||||
.to_owned(),
|
||||
),
|
||||
];
|
||||
for (var, file) in [
|
||||
("PGSSLROOTCERT", &source.ssl_ca_file),
|
||||
("PGSSLCERT", &source.ssl_cert_file),
|
||||
("PGSSLKEY", &source.ssl_key_file),
|
||||
] {
|
||||
if !file.trim().is_empty() {
|
||||
env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned()));
|
||||
}
|
||||
}
|
||||
if source.read_only {
|
||||
env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned()));
|
||||
}
|
||||
(args, env)
|
||||
}
|
||||
|
||||
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
|
||||
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
|
||||
fn dbname_arg(name: &str) -> String {
|
||||
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
|
||||
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
|
||||
} else {
|
||||
name.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
/// How a tool is started: connection arguments, then the job's, and the environment.
|
||||
pub struct Prepared {
|
||||
pub args: Vec<String>,
|
||||
pub env: Vec<(String, String)>,
|
||||
}
|
||||
|
||||
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
|
||||
/// arguments, which other users of the machine can read in the process list.
|
||||
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
|
||||
let (mut args, mut env) = connection(job.tool(), source);
|
||||
args.extend(job.args());
|
||||
if let Some(p) = password.filter(|p| !p.is_empty()) {
|
||||
env.push(("PGPASSWORD".into(), p.to_owned()));
|
||||
}
|
||||
Prepared { args, env }
|
||||
}
|
||||
|
||||
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
|
||||
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
|
||||
pub async fn run(
|
||||
program: &Path,
|
||||
args: &[String],
|
||||
env: &[(String, String)],
|
||||
cancel: &CancellationToken,
|
||||
mut on_output: impl FnMut(Vec<ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let mut cmd = tokio::process::Command::new(program);
|
||||
cmd.args(args)
|
||||
.envs(env.iter().map(|(k, v)| (k, v)))
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
ide_core::process::own_group(cmd.as_std_mut());
|
||||
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?;
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
if let Some(out) = child.stdout.take() {
|
||||
forward(out, false, tx.clone());
|
||||
}
|
||||
if let Some(err) = child.stderr.take() {
|
||||
forward(err, true, tx);
|
||||
}
|
||||
|
||||
let mut batch = Vec::new();
|
||||
let mut tick = tokio::time::interval(Duration::from_millis(100));
|
||||
loop {
|
||||
tokio::select! {
|
||||
line = rx.recv() => match line {
|
||||
Some(line) => {
|
||||
batch.push(line);
|
||||
if batch.len() >= 500 {
|
||||
on_output(std::mem::take(&mut batch));
|
||||
}
|
||||
}
|
||||
None => break,
|
||||
},
|
||||
_ = tick.tick() => {
|
||||
if !batch.is_empty() {
|
||||
on_output(std::mem::take(&mut batch));
|
||||
}
|
||||
}
|
||||
_ = cancel.cancelled() => {
|
||||
if let Some(pid) = child.id() {
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
}
|
||||
let _ = child.kill().await;
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
}
|
||||
}
|
||||
if !batch.is_empty() {
|
||||
on_output(batch);
|
||||
}
|
||||
let status = tokio::select! {
|
||||
status = child.wait() => status?,
|
||||
_ = cancel.cancelled() => {
|
||||
if let Some(pid) = child.id() {
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
}
|
||||
let _ = child.kill().await;
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
};
|
||||
Ok(status.code())
|
||||
}
|
||||
|
||||
fn forward(
|
||||
pipe: impl AsyncRead + Unpin + Send + 'static,
|
||||
stderr: bool,
|
||||
tx: tokio::sync::mpsc::UnboundedSender<ToolLine>,
|
||||
) {
|
||||
tokio::spawn(async move {
|
||||
let mut reader = BufReader::new(pipe);
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
match reader.read_until(b'\n', &mut buf).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {
|
||||
let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned();
|
||||
if tx.send(ToolLine { stderr, text }).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn pg() -> DataSource {
|
||||
DataSource {
|
||||
driver: DbDriver::Postgres,
|
||||
host: "db.example.test".into(),
|
||||
port: Some(6543),
|
||||
user: "app".into(),
|
||||
database: "shop".into(),
|
||||
..DataSource::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connects_like_the_data_source_without_prompting() {
|
||||
let (args, env) = connection(DbTool::PgDump, &pg());
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
|
||||
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_database_named_like_connection_parameters_stays_a_name() {
|
||||
for (name, arg) in [
|
||||
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
|
||||
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
|
||||
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
|
||||
] {
|
||||
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
|
||||
assert!(args.contains(&arg.to_owned()), "{args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_port_and_optional_fields() {
|
||||
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
|
||||
let (args, _) = connection(DbTool::Psql, &source);
|
||||
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_only_sources_refuse_writes() {
|
||||
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
|
||||
let (_, env) = connection(DbTool::PgRestore, &source);
|
||||
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
|
||||
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_the_tool_itself_is_accepted() {
|
||||
for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] {
|
||||
assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}");
|
||||
}
|
||||
for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] {
|
||||
assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tells_dumps_apart_by_their_header() {
|
||||
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
|
||||
assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive);
|
||||
assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql);
|
||||
assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql);
|
||||
assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql);
|
||||
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn newer_versions_sort_first() {
|
||||
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn streams_both_pipes_and_reports_the_exit_code() {
|
||||
let mut lines = Vec::new();
|
||||
let code = run(
|
||||
Path::new("/bin/sh"),
|
||||
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
|
||||
&[],
|
||||
&CancellationToken::new(),
|
||||
|batch| lines.extend(batch),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(code, Some(3));
|
||||
assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() }));
|
||||
assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() }));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancelling_stops_the_process() {
|
||||
let cancel = CancellationToken::new();
|
||||
let stop = cancel.clone();
|
||||
tokio::spawn(async move {
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
stop.cancel();
|
||||
});
|
||||
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
|
||||
/// holds the expected password.
|
||||
#[cfg(unix)]
|
||||
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = dir.join(tool.program());
|
||||
std::fs::write(
|
||||
&path,
|
||||
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn the_password_never_reaches_the_arguments() {
|
||||
const SECRET: &str = "s3cret-pass-do-not-leak";
|
||||
let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let file = dir.join("out.sql").to_string_lossy().into_owned();
|
||||
let jobs = [
|
||||
DbToolJob::PgDump {
|
||||
file: file.clone(),
|
||||
options: DbPgDumpOptions {
|
||||
format: DbDumpFormat::Plain,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec!["public".into()],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: true,
|
||||
if_exists: true,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
},
|
||||
},
|
||||
DbToolJob::Psql {
|
||||
file: file.clone(),
|
||||
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
|
||||
},
|
||||
];
|
||||
for job in jobs {
|
||||
let program = echo_tool(&dir, job.tool());
|
||||
let prepared = prepare(&job, &pg(), Some(SECRET));
|
||||
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
|
||||
let mut lines = Vec::new();
|
||||
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
|
||||
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
|
||||
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
|
||||
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
|
||||
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
|
||||
}
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -228,3 +228,78 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
|
||||
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
|
||||
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
|
||||
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
|
||||
let mut lines = Vec::new();
|
||||
let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
|
||||
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
|
||||
use ide_db::tools::{
|
||||
DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool,
|
||||
DbToolJob, find_installs,
|
||||
};
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let Some(db) = manager(&tmp).await else { return Ok(()) };
|
||||
let server = db.server_version("p").await? / 10000;
|
||||
let major = |t: DbTool| {
|
||||
find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::<u32>().ok())
|
||||
};
|
||||
// Other major versions write or refuse what this server needs; the dialogs warn about that instead.
|
||||
if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) {
|
||||
return Ok(());
|
||||
}
|
||||
create_schemas(&db).await;
|
||||
let c = CancellationToken::new();
|
||||
db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?;
|
||||
db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?;
|
||||
let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned();
|
||||
|
||||
let dump = |format, file: String, schema: &str| DbToolJob::PgDump {
|
||||
file,
|
||||
options: DbPgDumpOptions {
|
||||
format,
|
||||
statements: DbDumpStatements::Copy,
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![schema.into()],
|
||||
tables: vec![],
|
||||
exclude_tables: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
create: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
jobs: 1,
|
||||
},
|
||||
};
|
||||
let archive = file("a.dump");
|
||||
run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?;
|
||||
let restore = DbPgRestoreOptions {
|
||||
content: DbDumpContent::All,
|
||||
schemas: vec![],
|
||||
clean: false,
|
||||
if_exists: false,
|
||||
no_owner: false,
|
||||
no_privileges: false,
|
||||
single_transaction: false,
|
||||
exit_on_error: true,
|
||||
jobs: 1,
|
||||
};
|
||||
run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?;
|
||||
|
||||
let script = file("b.sql");
|
||||
run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?;
|
||||
let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true };
|
||||
run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?;
|
||||
|
||||
let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?;
|
||||
assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b"));
|
||||
db.disconnect("p:oi_restore").await;
|
||||
db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -26,6 +26,8 @@ pub enum Capability {
|
||||
DatabaseSources,
|
||||
VcsRead,
|
||||
VcsWrite,
|
||||
/// The Maven / Gradle dependency graph the IDE resolved.
|
||||
BuildRead,
|
||||
/// The plugin's own key-value store and data directory.
|
||||
Storage,
|
||||
/// The plugin's own secrets (kept in the client's OS keychain).
|
||||
@@ -55,6 +57,9 @@ pub enum Capability {
|
||||
FsRead(String),
|
||||
/// Write files outside the project under one path.
|
||||
FsWrite(String),
|
||||
/// Load the plugin's Java agent into the JVMs of Java run configurations. Never
|
||||
/// declared: it comes from `[[contributes.javaAgents]]`.
|
||||
JavaAgent,
|
||||
}
|
||||
|
||||
/// How a grant is presented (plan 4.2).
|
||||
@@ -72,7 +77,9 @@ pub enum Risk {
|
||||
impl Capability {
|
||||
pub fn risk(&self) -> Risk {
|
||||
match self {
|
||||
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
|
||||
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
|
||||
Risk::Low
|
||||
}
|
||||
Self::EditorWrite
|
||||
| Self::DatabaseSources
|
||||
| Self::VcsWrite
|
||||
@@ -90,7 +97,8 @@ impl Capability {
|
||||
| Self::Process(_)
|
||||
| Self::Lsp(_)
|
||||
| Self::FsRead(_)
|
||||
| Self::FsWrite(_) => Risk::High,
|
||||
| Self::FsWrite(_)
|
||||
| Self::JavaAgent => Risk::High,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -111,6 +119,7 @@ impl Capability {
|
||||
Self::IdeCommands => "Run any IDE action or other plugins' commands as if you chose them, including running programs, committing and pushing".into(),
|
||||
Self::VcsRead => "Read version control state".into(),
|
||||
Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
|
||||
Self::BuildRead => "Read the project's resolved Maven and Gradle dependencies".into(),
|
||||
Self::Storage => "Store its own data".into(),
|
||||
Self::Secrets => "Store secrets in the system keychain".into(),
|
||||
Self::Events => "Observe editor, filesystem and version control events".into(),
|
||||
@@ -135,6 +144,7 @@ impl Capability {
|
||||
}
|
||||
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
|
||||
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
|
||||
Self::JavaAgent => "Run code inside the Java applications you start".into(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -246,6 +256,7 @@ impl fmt::Display for Capability {
|
||||
Self::DatabaseSources => f.write_str("database.sources"),
|
||||
Self::VcsRead => f.write_str("vcs.read"),
|
||||
Self::VcsWrite => f.write_str("vcs.write"),
|
||||
Self::BuildRead => f.write_str("build.read"),
|
||||
Self::Storage => f.write_str("storage"),
|
||||
Self::Secrets => f.write_str("secrets"),
|
||||
Self::Events => f.write_str("events"),
|
||||
@@ -259,6 +270,7 @@ impl fmt::Display for Capability {
|
||||
Self::Lsp(s) => write!(f, "lsp:{s}"),
|
||||
Self::FsRead(p) => write!(f, "fs.read:{p}"),
|
||||
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
|
||||
Self::JavaAgent => f.write_str("java.agent"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -330,11 +342,13 @@ impl FromStr for Capability {
|
||||
"database.sources" => Self::DatabaseSources,
|
||||
"vcs.read" => Self::VcsRead,
|
||||
"vcs.write" => Self::VcsWrite,
|
||||
"build.read" => Self::BuildRead,
|
||||
"storage" => Self::Storage,
|
||||
"secrets" => Self::Secrets,
|
||||
"events" => Self::Events,
|
||||
"events.input" => Self::InputEvents,
|
||||
"clipboard" => Self::Clipboard,
|
||||
"java.agent" => Self::JavaAgent,
|
||||
_ => return Err(format!("unknown capability {s:?}")),
|
||||
})
|
||||
}
|
||||
@@ -383,6 +397,7 @@ mod tests {
|
||||
"editor.write",
|
||||
"project.write",
|
||||
"vcs.write",
|
||||
"build.read",
|
||||
"storage",
|
||||
"secrets",
|
||||
"events",
|
||||
@@ -392,6 +407,7 @@ mod tests {
|
||||
"process:cargo",
|
||||
"lsp:phoxite",
|
||||
"lsp:rust-analyzer",
|
||||
"java.agent",
|
||||
] {
|
||||
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
|
||||
}
|
||||
@@ -425,8 +441,11 @@ mod tests {
|
||||
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
|
||||
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::BuildRead.risk(), Risk::Low);
|
||||
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
|
||||
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
|
||||
assert_eq!(Capability::JavaAgent.risk(), Risk::High);
|
||||
assert!(!Capability::JavaAgent.auto_migrates());
|
||||
}
|
||||
|
||||
/// A trusted project's files name programs the IDE starts by itself: the git and language
|
||||
|
||||
@@ -10,6 +10,8 @@
|
||||
//! - `process:<program>` grants record the program's absolute path and file
|
||||
//! hash at grant time. Calls use that path, never a `PATH` lookup, and fail
|
||||
//! when the file changed (re-confirmation needed).
|
||||
//! - `java.agent` grants record the agent jar's path and hash the same way;
|
||||
//! a launch adds the agent only while the jar still has that hash.
|
||||
|
||||
use crate::capability::{Capability, Risk};
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -267,7 +269,7 @@ impl Ledger {
|
||||
if cap == &Capability::NetAsk {
|
||||
grant.net_hosts.clear();
|
||||
}
|
||||
if let Capability::Process(_) = cap {
|
||||
if let Capability::Process(_) | Capability::JavaAgent = cap {
|
||||
grant.binaries.remove(&s);
|
||||
for binaries in grant.project_binaries.values_mut() {
|
||||
binaries.remove(&s);
|
||||
@@ -290,7 +292,7 @@ impl Ledger {
|
||||
self.grants.get_mut(subject).is_some_and(|g| g.net_hosts.remove(host))
|
||||
}
|
||||
|
||||
/// Records the program approved for a `process:` grant.
|
||||
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
|
||||
pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
|
||||
if let Some(grant) = self.grants.get_mut(subject) {
|
||||
grant.binaries.insert(cap.to_string(), binary);
|
||||
@@ -675,6 +677,21 @@ mod tests {
|
||||
assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn revoking_java_agent_forgets_its_jar() {
|
||||
let mut l = Ledger::in_memory();
|
||||
let r = req("1.0.0", "h", &[], &["java.agent"]);
|
||||
let cap = Capability::JavaAgent;
|
||||
let jar = BinaryGrant { path: "/plugins/p/agent.jar".into(), hash: "abc".into() };
|
||||
l.confirm(&r, std::slice::from_ref(&cap), [(cap.to_string(), jar.clone())].into());
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), Some(jar.clone()));
|
||||
l.set(&r.subject, &cap, false);
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
|
||||
// Granting again without a new hash does not bring the old one back.
|
||||
l.set(&r.subject, &cap, true);
|
||||
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashes_and_grouping() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
|
||||
|
||||
pub const MANIFEST_FILE: &str = "plugin.toml";
|
||||
/// The plugin API (engine) version this host implements.
|
||||
pub const ENGINE_VERSION: &str = "1.9.0";
|
||||
pub const ENGINE_VERSION: &str = "1.10.0";
|
||||
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
|
||||
pub const LEGACY_API: &str = "0.1";
|
||||
/// Marketplace categories, in the order they are shown.
|
||||
@@ -360,6 +360,14 @@ impl Manifest {
|
||||
if matches!(cap, Capability::Lsp(_)) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 9)?;
|
||||
}
|
||||
if matches!(cap, Capability::BuildRead) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 10)?;
|
||||
}
|
||||
if matches!(cap, Capability::JavaAgent) {
|
||||
return Err(
|
||||
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some(dark) = &self.icon_dark {
|
||||
if self.icon.is_none() {
|
||||
@@ -730,6 +738,22 @@ required = [\"lsp:phoxite\"]
|
||||
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_build_capability_needs_api_1_10() {
|
||||
let caps = "[capabilities]\noptional = [\"build.read\"]\n";
|
||||
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).contains("new in plugin API 1.10"));
|
||||
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).unwrap();
|
||||
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn java_agent_capability_is_not_declared() {
|
||||
for list in ["required", "optional"] {
|
||||
let caps = format!("[capabilities]\n{list} = [\"java.agent\"]\n");
|
||||
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("contributes.javaAgents"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_icons() {
|
||||
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
|
||||
|
||||
@@ -30,6 +30,8 @@ ide-vcs.workspace = true
|
||||
ide-dap.workspace = true
|
||||
ide-heap.workspace = true
|
||||
ide-jvm-attach.workspace = true
|
||||
ide-jvm-inspect.workspace = true
|
||||
ide-streams.workspace = true
|
||||
ide-build.workspace = true
|
||||
ide-analysis.workspace = true
|
||||
ide-coverage.workspace = true
|
||||
|
||||
@@ -25,12 +25,17 @@ impl Scope {
|
||||
} else {
|
||||
call.root().join(given)
|
||||
});
|
||||
let roots: Vec<PathBuf> =
|
||||
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
|
||||
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
|
||||
if !ide_vfs::content_path_allowed(&path, &roots) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
let path = dunce::canonicalize(&path).unwrap_or(path);
|
||||
if !path.is_dir() {
|
||||
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
|
||||
}
|
||||
let roots = std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots());
|
||||
if !roots.into_iter().any(|root| path.starts_with(root)) {
|
||||
if !roots.iter().any(|root| path.starts_with(root)) {
|
||||
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
|
||||
}
|
||||
Ok(Self(Some(path)))
|
||||
|
||||
@@ -883,14 +883,20 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let host = call.host();
|
||||
let project = call.project().clone();
|
||||
let indexing_before = project.index.status().indexing;
|
||||
let pool = if scope.is_all() && dir.dir().is_none() {
|
||||
limit + 1
|
||||
} else {
|
||||
((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL)
|
||||
};
|
||||
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
|
||||
let found = {
|
||||
let (project, q) = (project.clone(), q.clone());
|
||||
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
|
||||
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
|
||||
host.blocking(move || {
|
||||
Ok(match dir {
|
||||
// Filtered in the index: a pool cut before the filter could miss every match.
|
||||
Some(dir) => project
|
||||
.index
|
||||
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
|
||||
.unwrap_or_default(),
|
||||
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
|
||||
})
|
||||
})
|
||||
.await?
|
||||
};
|
||||
let mut items: Vec<SearchItem> = found
|
||||
.into_iter()
|
||||
@@ -910,10 +916,14 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
|
||||
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
|
||||
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
|
||||
timed_out = out_of_time;
|
||||
let mut roots = project.content_roots();
|
||||
roots.extend(crate::mcp::tool::attached_projects(call.root()));
|
||||
for (name, container, location) in symbols {
|
||||
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
|
||||
// Project files obey `scope` and `paths`; library symbols are what was asked for.
|
||||
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
|
||||
// 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 && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -30,9 +30,15 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
|
||||
}
|
||||
|
||||
/// Refreshes the selected agent's model catalog without sending a prompt.
|
||||
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
pub fn refresh_models(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
force: bool,
|
||||
model: Option<String>,
|
||||
) -> IdeResult<AgentModelCatalog> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.refresh_models(&provider, force)
|
||||
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
|
||||
}
|
||||
|
||||
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
|
||||
@@ -832,7 +838,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
|
||||
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
|
||||
d.add("agent_refresh_models", |c| async move {
|
||||
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
|
||||
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
|
||||
});
|
||||
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
|
||||
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
|
||||
|
||||
@@ -311,12 +311,11 @@ pub async fn build_sync(
|
||||
if completion_token.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
if tool == BuildTool::Gradle {
|
||||
// The sync may report project folders outside the project (`includeFlat`): index and list them.
|
||||
project.refresh_index_scope();
|
||||
let p = project.clone();
|
||||
tokio::task::spawn_blocking(move || p.refresh_repositories());
|
||||
}
|
||||
// Gradle may report project folders outside the project (`includeFlat`), and a Maven
|
||||
// reactor may have gained or dropped modules beside it: index and list them.
|
||||
project.refresh_index_scope();
|
||||
let p = project.clone();
|
||||
tokio::task::spawn_blocking(move || p.refresh_repositories());
|
||||
// New source folders and dependency versions: the Project view and External Libraries reload.
|
||||
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
|
||||
if tool == BuildTool::Maven
|
||||
@@ -468,7 +467,15 @@ pub async fn gradle_dependencies(
|
||||
gradle_command: Some(gradle.command.clone()),
|
||||
..Default::default()
|
||||
};
|
||||
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
|
||||
let dependencies =
|
||||
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)?;
|
||||
// What plugins read of the build (`build.dependencies`) instead of running Gradle.
|
||||
let report = ide_build::GradleReport { project: gradle_path, configuration, dependencies };
|
||||
let cache = ide_build::gradle::cache_dir(&scope.cache, &gradle.dir);
|
||||
if let Err(e) = ide_build::save_gradle_report(&scope.root, &cache, gradle, &report) {
|
||||
tracing::debug!("keeping the dependencies report of {}: {e}", report.project);
|
||||
}
|
||||
Ok(report.dependencies)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
@@ -476,6 +483,40 @@ pub async fn gradle_dependencies(
|
||||
result?
|
||||
}
|
||||
|
||||
/// What the Dependency Analyzer has of the builds of `project` at `root` (the project, or one
|
||||
/// of its workspace members), without running a build tool: the Maven modules as last synced
|
||||
/// and the Gradle reports read since the build files last changed.
|
||||
pub(crate) fn analyzed_dependencies(
|
||||
project: &Project,
|
||||
config: &Path,
|
||||
root: &Path,
|
||||
) -> IdeResult<crate::plugins::BuildGraph> {
|
||||
let mut graph = crate::plugins::BuildGraph::default();
|
||||
for scope in workspace::scopes(project, config)?.iter().filter(|s| root == project.root || s.root == root) {
|
||||
let settings = &scope.settings;
|
||||
let model = ide_build::load_linked(
|
||||
&scope.root,
|
||||
&scope.cache,
|
||||
ide_sdk::apply::maven_local_repository(&scope.root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
);
|
||||
graph.maven.extend(model.maven.into_iter().flat_map(|m| m.projects));
|
||||
for build in &model.gradle {
|
||||
let reports =
|
||||
ide_build::gradle_reports(&scope.root, &ide_build::gradle::cache_dir(&scope.cache, &build.dir), build);
|
||||
// buildSrc can't be analyzed from the build, as in the Dependency Analyzer.
|
||||
for p in build.projects.iter().filter(|p| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"))) {
|
||||
graph.gradle.push(crate::plugins::GradleModule {
|
||||
path: p.path.clone(),
|
||||
reports: reports.iter().filter(|r| r.project == p.path).cloned().collect(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(graph)
|
||||
}
|
||||
|
||||
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
|
||||
pub async fn maven_dependency_declaration(
|
||||
host: &Host,
|
||||
|
||||
@@ -532,3 +532,35 @@ fn console_dir(host: &Host, id: &str) -> IdeResult<PathBuf> {
|
||||
std::fs::create_dir_all(&dir)?;
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
/// Runs a client tool against target `id` until it exits or the request is cancelled.
|
||||
/// Desktop only: the file paths come from local dialogs.
|
||||
pub async fn run_tool(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
request: RequestId,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &ide_db::tools::DbToolJob,
|
||||
on_output: impl FnMut(Vec<ide_db::tools::ToolLine>),
|
||||
) -> IdeResult<Option<i32>> {
|
||||
let db = host.project(window)?.db.clone();
|
||||
let cancel = host.begin_request(request);
|
||||
let result = db.run_tool(id, executable, job, &cancel, on_output).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
pub fn tool_preview(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
id: &str,
|
||||
executable: &std::path::Path,
|
||||
job: &ide_db::tools::DbToolJob,
|
||||
) -> IdeResult<String> {
|
||||
host.project(window)?.db.tool_preview(id, executable, job)
|
||||
}
|
||||
|
||||
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
|
||||
host.project(window)?.db.server_version(id).await
|
||||
}
|
||||
@@ -31,6 +31,8 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
|
||||
let config = add_java_agents(config, &agents.options);
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -119,6 +121,15 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
let server_port = debug_server_port(&config);
|
||||
let result = host.debugger.start_with(config, owner, custom).await;
|
||||
flush_output();
|
||||
if let Ok(id) = &result {
|
||||
let sink = host.window_sink(label);
|
||||
for note in &agents.notes {
|
||||
sink.emit(ide_core::IdeEvent::Debug {
|
||||
session: *id,
|
||||
event: ide_core::event::DebugEvent::Output { category: "console".into(), output: format!("{note}\n") },
|
||||
});
|
||||
}
|
||||
}
|
||||
if result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
@@ -154,10 +165,54 @@ fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port: u16) {
|
||||
let Ok(project) = host.project(window) else { return };
|
||||
let Some(module) = project.lsp.java_debug_server_module(port) else { return };
|
||||
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module));
|
||||
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
|
||||
if let Err(e) = host.debugger.set_jvm_inspector(session, inspector) {
|
||||
tracing::debug!("jvm inspector for session {session:?}: {e}");
|
||||
return;
|
||||
}
|
||||
let tracer = std::sync::Arc::new(ide_lsp::JdtStreamTracer::new(project.lsp.clone(), module));
|
||||
if let Err(e) = host.debugger.set_stream_tracer(session, tracer) {
|
||||
tracing::debug!("stream tracer for session {session:?}: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
|
||||
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
|
||||
fn is_jvm_launch(config: &LaunchConfig) -> bool {
|
||||
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
|
||||
}
|
||||
|
||||
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
|
||||
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
|
||||
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
|
||||
if options.is_empty() || !is_jvm_launch(&config) {
|
||||
return config;
|
||||
}
|
||||
let Some(serde_json::Value::Object(mut extra)) =
|
||||
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok())
|
||||
else {
|
||||
return config;
|
||||
};
|
||||
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
|
||||
let value = match extra.get(key) {
|
||||
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
|
||||
ide_run::java_agent::add_to_vm_args_text("", options).into()
|
||||
}
|
||||
Some(serde_json::Value::String(text)) => ide_run::java_agent::add_to_vm_args_text(text, options).into(),
|
||||
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Array(_)) => {
|
||||
let mut list: Vec<String> = extra
|
||||
.get(key)
|
||||
.and_then(serde_json::Value::as_array)
|
||||
.map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
|
||||
.unwrap_or_default();
|
||||
ide_run::java_agent::add_to_vm_args(&mut list, options);
|
||||
list.into()
|
||||
}
|
||||
Some(_) => return config,
|
||||
};
|
||||
extra.insert(key.into(), value);
|
||||
config.extra_json = Some(serde_json::Value::Object(extra).to_string());
|
||||
config
|
||||
}
|
||||
|
||||
/// The JVM memory tab reads the class table over the attach socket, which only exists once the
|
||||
@@ -813,6 +868,36 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plugin_java_agents_join_the_vm_options_of_jvm_launches() {
|
||||
let agent = "-javaagent:/my plugins/agent.jar=port=0".to_owned();
|
||||
let options = std::slice::from_ref(&agent);
|
||||
let field = |config: &LaunchConfig, key: &str| {
|
||||
serde_json::from_str::<serde_json::Value>(config.extra_json.as_deref().unwrap()).unwrap()[key].clone()
|
||||
};
|
||||
let debugged =
|
||||
add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})), options);
|
||||
assert_eq!(vm_args(&debugged), "-Xmx1g \"-javaagent:/my plugins/agent.jar=port=0\"");
|
||||
assert_eq!(add_java_agents(debugged.clone(), options).extra_json, debugged.extra_json, "not added twice");
|
||||
let none = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": null})), options);
|
||||
assert_eq!(vm_args(&none), "\"-javaagent:/my plugins/agent.jar=port=0\"");
|
||||
let list = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]})), options);
|
||||
assert_eq!(vm_args(&list), serde_json::json!(["-Xmx1g", agent]));
|
||||
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({"vmArguments": ["-Xmx1g"]}));
|
||||
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
|
||||
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
|
||||
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
|
||||
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
|
||||
for config in [
|
||||
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
|
||||
launch("debugpy", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})),
|
||||
] {
|
||||
assert_eq!(add_java_agents(config.clone(), options).extra_json, config.extra_json);
|
||||
}
|
||||
let config = launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"}));
|
||||
assert_eq!(add_java_agents(config.clone(), &[]).extra_json, config.extra_json);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn debug_server_port_only_for_local_java_debug() {
|
||||
let port = |adapter: &str, request: &str, extra| debug_server_port(&launch(adapter, request, extra));
|
||||
|
||||
@@ -5,7 +5,7 @@ use crate::rpc::Dispatcher;
|
||||
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
|
||||
use ide_language::{FoldRange, SyntaxHighlights};
|
||||
use ide_text::LineEnding;
|
||||
use ide_workspace::{DocumentEncoding, DocumentInfo, HistoryEntry};
|
||||
use ide_workspace::{DocumentEncoding, DocumentInfo, DocumentLanguage, HistoryEntry};
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool,
|
||||
@@ -32,11 +32,17 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
|
||||
.await
|
||||
}
|
||||
|
||||
/// The CodeMirror mode `path` gets when opened (`DocumentInfo::ui_mode`),
|
||||
/// without opening it: previews of closed files.
|
||||
pub async fn doc_ui_mode(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<String>> {
|
||||
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
|
||||
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
|
||||
/// for hashbang detection; without it the file's on disk counts.
|
||||
pub async fn doc_language(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
path: PathBuf,
|
||||
first_line: Option<String>,
|
||||
) -> IdeResult<DocumentLanguage> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.documents.ui_mode_of(&path))).await
|
||||
blocking(move || Ok(project.documents.language_of(&path, first_line.as_deref()))).await
|
||||
}
|
||||
|
||||
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
|
||||
@@ -209,7 +215,10 @@ pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<Strin
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
|
||||
d.add("doc_ui_mode", |c| async move { doc_ui_mode(&c.host, &c.window, c.arg("path")?).await });
|
||||
d.add(
|
||||
"doc_language",
|
||||
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
|
||||
);
|
||||
d.add("doc_set_encoding", |c| async move {
|
||||
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
|
||||
});
|
||||
|
||||
@@ -33,6 +33,7 @@ pub mod sdk;
|
||||
pub mod search;
|
||||
pub mod spell;
|
||||
mod ssh;
|
||||
pub mod stream_trace;
|
||||
pub mod syntax;
|
||||
pub mod term;
|
||||
pub mod tools;
|
||||
@@ -88,6 +89,7 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
|
||||
java::register(d);
|
||||
debug::register(d);
|
||||
heap::register(d);
|
||||
stream_trace::register(d);
|
||||
bytes::register(d);
|
||||
vcs::register(d);
|
||||
doc::register(d);
|
||||
|
||||
@@ -208,41 +208,52 @@ pub async fn nav_index_definitions(
|
||||
}
|
||||
|
||||
/// Every Python class in the project (attached dependency roots included) and its base
|
||||
/// names. The index covers content roots, so this is the whole-project answer the UI uses
|
||||
/// for inheritance gutter markers when no type-hierarchy provider exists.
|
||||
/// names, answered from the project index: its symbols already carry the bases, and it
|
||||
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
|
||||
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
|
||||
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
|
||||
let project = host.project(window)?;
|
||||
let syntax = host.syntax();
|
||||
blocking(move || {
|
||||
let python = LanguageId::new("python");
|
||||
let files = project.index.files_with_extensions(&["py".into(), "pyi".into()], 20_000);
|
||||
let mut cache = CLASS_BASES.lock();
|
||||
let mut out = Vec::new();
|
||||
for path in files {
|
||||
// The open (possibly unsaved) buffer is keyed by its text, a file on disk by its
|
||||
// size and modification time, so only changed files are parsed again.
|
||||
// Disk-backed classes come from the index: it already parsed every file once for
|
||||
// symbols, so no second parse of the project is needed here.
|
||||
let mut out: Vec<ClassInheritance> = project
|
||||
.index
|
||||
.inheritance()
|
||||
.into_iter()
|
||||
// The index holds classes of every language; the graph is Python's.
|
||||
.filter(|c| matches!(c.path.extension().and_then(std::ffi::OsStr::to_str), Some("py" | "pyi")))
|
||||
.map(|c| ClassInheritance {
|
||||
path: IpcPath::from(c.path.clone()),
|
||||
line: c.range.start.line,
|
||||
col: c.range.start.col,
|
||||
name: c.name.clone(),
|
||||
bases: c.bases.clone(),
|
||||
})
|
||||
.collect();
|
||||
// Open buffers may be unsaved, so their classes are parsed live (and cached per
|
||||
// text/stamp) and replace the index's view of that file. This keeps #3359's
|
||||
// "open buffer by its text" behaviour while the disk path is index-backed.
|
||||
let open_files: Vec<PathBuf> = project
|
||||
.index
|
||||
.files_with_extensions(&["py".into(), "pyi".into()], 20_000)
|
||||
.into_iter()
|
||||
.filter(|path| project.documents.text_of(path).is_some())
|
||||
.collect();
|
||||
for path in open_files {
|
||||
let open = project.documents.text_of(&path);
|
||||
let stamp = match &open {
|
||||
Some(text) => Stamp::Text(text_hash(text)),
|
||||
None => match std::fs::metadata(&path) {
|
||||
Ok(m) => Stamp::Disk(m.len(), m.modified().ok()),
|
||||
Err(_) => continue,
|
||||
},
|
||||
Some(text) => Stamp(text_hash(text)),
|
||||
None => continue,
|
||||
};
|
||||
let text = open.unwrap();
|
||||
let classes = match cache.get(&path) {
|
||||
Some((cached, classes)) if *cached == stamp => classes,
|
||||
_ => {
|
||||
let text = match open {
|
||||
Some(text) => text,
|
||||
None => match project.text_of(&path) {
|
||||
Ok(text) => text,
|
||||
Err(_) => continue,
|
||||
},
|
||||
};
|
||||
let classes = syntax.class_bases(&python, &text);
|
||||
&cache.entry(path.clone()).insert_entry((stamp, classes)).into_mut().1
|
||||
}
|
||||
_ => &cache.entry(path.clone()).insert_entry((stamp, syntax.class_bases(&python, &text))).into_mut().1,
|
||||
};
|
||||
out.retain(|c| c.path.0 != *path);
|
||||
out.extend(classes.iter().map(|class| ClassInheritance {
|
||||
path: IpcPath::from(path.clone()),
|
||||
line: class.line,
|
||||
@@ -257,10 +268,7 @@ pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassIn
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
enum Stamp {
|
||||
Text(u64),
|
||||
Disk(u64, Option<std::time::SystemTime>),
|
||||
}
|
||||
struct Stamp(u64);
|
||||
|
||||
fn text_hash(text: &str) -> u64 {
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
@@ -301,6 +301,8 @@ async fn start_inner(
|
||||
if config.command.is_empty() {
|
||||
return Err(IdeError::invalid("run configuration has no command"));
|
||||
}
|
||||
let on_target = config.extras.target.as_deref().is_some_and(|t| !t.is_empty());
|
||||
add_java_agents(&mut config, &on_output, !on_target);
|
||||
// Settings › Run Targets: over SSH, or in a container.
|
||||
if config.kind == "tomcat" && config.extras.target.as_deref().is_some_and(|t| !t.is_empty()) {
|
||||
return Err(IdeError::invalid("Tomcat Local requires the local machine"));
|
||||
@@ -446,6 +448,29 @@ async fn start_inner(
|
||||
host.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))
|
||||
}
|
||||
|
||||
/// Plugins' Java agents (`[[contributes.javaAgents]]`, granted `java.agent`) for the JVM of an
|
||||
/// Application, Spring Boot or JAR Application configuration started on this machine. A JVM on a
|
||||
/// run target gets none; the console says so, and why an approved agent was left out.
|
||||
fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local: bool) {
|
||||
if !ide_run::java_agent::applies(&config.kind) {
|
||||
return;
|
||||
}
|
||||
let agents = ide_run::java_agent::current();
|
||||
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
|
||||
if !local {
|
||||
if !agents.options.is_empty() {
|
||||
say(
|
||||
"Plugin Java agents were not added: they load only into JVMs started on this machine, not on a run target.",
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
for note in &agents.notes {
|
||||
say(note);
|
||||
}
|
||||
ide_run::java_agent::add_to_args(&mut config.args, &agents.options);
|
||||
}
|
||||
|
||||
/// The Ruby test reporter's directory, installed on demand, for runs that take it.
|
||||
fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {
|
||||
if !ide_run::ruby_reporter::applies(config) {
|
||||
|
||||
@@ -65,6 +65,7 @@ pub async fn spell_check(
|
||||
end: r.end,
|
||||
kind: match r.kind {
|
||||
SpellingKind::Comment => RegionKind::Comment,
|
||||
SpellingKind::String if r.raw => RegionKind::RawString,
|
||||
SpellingKind::String => RegionKind::String,
|
||||
SpellingKind::Name => RegionKind::Name,
|
||||
},
|
||||
|
||||
@@ -0,0 +1,466 @@
|
||||
//! Java Stream Debugger: the stream chains around a debugger stop, and traces of a chain's real run.
|
||||
//! `ide_streams` finds the chains and links what the run recorded; `ide_dap` runs the trace.
|
||||
|
||||
use crate::Host;
|
||||
use crate::ops::Channel;
|
||||
use crate::rpc::Dispatcher;
|
||||
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
|
||||
use ide_dap::{StackFrame, TraceRun};
|
||||
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
|
||||
pub use ide_jvm_inspect::{AbortState, JvmValue};
|
||||
use ide_jvm_inspect::{CollectedTerminal, TraceCollected};
|
||||
use ide_streams::{
|
||||
BoxKind, RealRunPlan, RealRunRefusal, Record, Rejection, StopContext, StreamChain, TerminalOutcome, TraceRecording,
|
||||
TraceValue, find_chains, link_trace, real_run_plan, recorded_steps,
|
||||
};
|
||||
pub use ide_streams::{Link, TraceBanner};
|
||||
use ide_syntax::{Snapshot, StructureService};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct StreamChainInfo {
|
||||
/// The `chain_index` [`debug_stream_trace`] takes for the same frame.
|
||||
pub index: u32,
|
||||
pub range: Range,
|
||||
pub text: String,
|
||||
/// Intermediate operations in call order, modifiers included. Empty, like `terminal`, for a
|
||||
/// chain the search rejected.
|
||||
pub steps: Vec<String>,
|
||||
pub terminal: String,
|
||||
pub available: bool,
|
||||
/// Set exactly when `available` is false.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
#[specta(optional)]
|
||||
pub reason: Option<ChainUnavailable>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum ChainUnavailable {
|
||||
NotTopFrame,
|
||||
NotAtChainStart,
|
||||
InsideChainLambda,
|
||||
NotJavaStreamRoot {
|
||||
root: String,
|
||||
},
|
||||
LazyTerminal {
|
||||
op: String,
|
||||
},
|
||||
NoTerminal,
|
||||
UnknownOperation {
|
||||
op: String,
|
||||
},
|
||||
SyntaxError,
|
||||
/// The session has no stream tracer: not java-debug, or its jdtls has no inspector bundle.
|
||||
NoBackend,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "status", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum StreamTraceResult {
|
||||
Ready {
|
||||
chain: Box<StreamChainInfo>,
|
||||
/// Column titles by recorded step: `steps[0]` is the root call's name (empty for a stream
|
||||
/// held in a local), then each operation that records, modifiers left out.
|
||||
steps: Vec<String>,
|
||||
/// In recording order.
|
||||
records: Vec<TraceRecordView>,
|
||||
/// Parallel to `records`.
|
||||
links: Vec<Link>,
|
||||
terminal: TerminalView,
|
||||
banners: Vec<TraceBanner>,
|
||||
/// The stop the values belong to, for `debug_jvm_memory_fields`.
|
||||
generation: u64,
|
||||
},
|
||||
Unavailable {
|
||||
reason: TraceUnavailable,
|
||||
},
|
||||
Failed {
|
||||
detail: String,
|
||||
},
|
||||
/// Recording was stopped, or the operation aborted, before the chain ran: nothing went wrong.
|
||||
Cancelled {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct TraceRecordView {
|
||||
pub step: u16,
|
||||
pub value: JvmValue,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum TerminalView {
|
||||
Value { value: JvmValue },
|
||||
Void,
|
||||
Threw { exception: JvmValue },
|
||||
}
|
||||
|
||||
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
|
||||
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
|
||||
pub async fn debug_stream_chains(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
session: DebugSessionId,
|
||||
frame: StackFrame,
|
||||
top: bool,
|
||||
) -> IdeResult<Vec<StreamChainInfo>> {
|
||||
host.require_trust(window)?;
|
||||
let backend = host.debugger.capabilities(session)?.stream_trace;
|
||||
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
|
||||
}
|
||||
|
||||
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
|
||||
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
|
||||
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
|
||||
/// can move another chain to the same index. Cancelling `request` stops recording while the
|
||||
/// program runs on.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub async fn debug_stream_trace(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
session: DebugSessionId,
|
||||
request: RequestId,
|
||||
thread_id: i64,
|
||||
frame: StackFrame,
|
||||
chain_index: u32,
|
||||
range: Range,
|
||||
on_progress: Channel<TraceProgress>,
|
||||
) -> IdeResult<StreamTraceResult> {
|
||||
host.require_trust(window)?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let chain = ChainRef { frame, index: chain_index, range };
|
||||
let result = trace(host, window, session, thread_id, chain, &cancel, &on_progress).await;
|
||||
host.end_request(request);
|
||||
result
|
||||
}
|
||||
|
||||
/// The chain the UI chose, as [`debug_stream_chains`] listed it.
|
||||
struct ChainRef {
|
||||
frame: StackFrame,
|
||||
index: u32,
|
||||
range: Range,
|
||||
}
|
||||
|
||||
async fn trace(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
session: DebugSessionId,
|
||||
thread_id: i64,
|
||||
chosen: ChainRef,
|
||||
cancel: &CancellationToken,
|
||||
on_progress: &Channel<TraceProgress>,
|
||||
) -> IdeResult<StreamTraceResult> {
|
||||
let line = chosen.frame.line;
|
||||
// `stream_trace` decides whether the session can trace, so the backend is assumed here.
|
||||
let candidate = candidates(host, window, chosen.frame, true, true)
|
||||
.await?
|
||||
.into_iter()
|
||||
.nth(chosen.index as usize)
|
||||
.filter(|c| c.info.range == chosen.range);
|
||||
let Some(candidate) = candidate else {
|
||||
return Ok(StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() });
|
||||
};
|
||||
if let Some(reason) = candidate.info.reason.clone() {
|
||||
let reason = trace_unavailable(reason, line, candidate.chain.as_ref());
|
||||
return Ok(StreamTraceResult::Unavailable { reason });
|
||||
}
|
||||
let Some(chain) = candidate.chain else {
|
||||
return Err(IdeError::internal("an available stream chain has no parsed chain"));
|
||||
};
|
||||
let plan = real_run_plan(&chain).map_err(|e| IdeError::internal(format!("stream chain plan: {e:?}")))?;
|
||||
let plan_json = serde_json::to_value(&plan).map_err(|e| IdeError::internal(e.to_string()))?;
|
||||
// `stream_trace` resumes the program before it looks at `cancel`.
|
||||
if cancel.is_cancelled() {
|
||||
return Ok(StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() });
|
||||
}
|
||||
let progress = |p| {
|
||||
let _ = on_progress.send(p);
|
||||
};
|
||||
let run = host.debugger.stream_trace(session, thread_id, plan_json, cancel.clone(), progress).await?;
|
||||
Ok(match run {
|
||||
TraceRun::Done { collected, generation, resumed_stops } => {
|
||||
let info = candidate.info;
|
||||
host.blocking(move || Ok(ready(info, &chain, &plan, collected, generation, resumed_stops))).await?
|
||||
}
|
||||
TraceRun::Unavailable { reason } => StreamTraceResult::Unavailable { reason },
|
||||
TraceRun::Failed { detail } => StreamTraceResult::Failed { detail },
|
||||
TraceRun::Cancelled { detail } => StreamTraceResult::Cancelled { detail },
|
||||
})
|
||||
}
|
||||
|
||||
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
|
||||
pub async fn debug_stream_trace_abort(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
session: DebugSessionId,
|
||||
) -> IdeResult<Option<AbortState>> {
|
||||
host.require_trust(window)?;
|
||||
host.debugger.stream_trace_abort(session).await
|
||||
}
|
||||
|
||||
struct Candidate {
|
||||
info: StreamChainInfo,
|
||||
/// `None` for a chain the search rejected.
|
||||
chain: Option<StreamChain>,
|
||||
}
|
||||
|
||||
/// The file's current text (the open buffer, else the disk) searched off the command thread.
|
||||
/// Frames outside readable Java sources have no chains: java-debug gives library frames
|
||||
/// `jdt://contents/…` paths.
|
||||
async fn candidates(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
frame: StackFrame,
|
||||
top: bool,
|
||||
backend: bool,
|
||||
) -> IdeResult<Vec<Candidate>> {
|
||||
let Some(path) = frame.path.clone() else { return Ok(Vec::new()) };
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || {
|
||||
let path = path.into_path_buf();
|
||||
let cancel = CancellationToken::new();
|
||||
let search = |snap: &Snapshot| {
|
||||
if snap.language.as_str() != "java" {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
chains_at(&project.structure, snap, &frame, top, backend, &cancel)
|
||||
};
|
||||
if let Some(doc) = project.documents.by_path(&path) {
|
||||
let snap = project.documents.text_snapshot(doc)?;
|
||||
if snap.large {
|
||||
return Err(IdeError::unavailable("file is too large for syntax analysis"));
|
||||
}
|
||||
return search(&Snapshot::doc(doc, snap.version, &snap.language, &snap.text));
|
||||
}
|
||||
let language: LanguageId = project.languages.detect(&path, None);
|
||||
if language.as_str() != "java" {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let Ok(text) = project.text_of(&path) else { return Ok(Vec::new()) };
|
||||
search(&Snapshot::text(&language, &text))
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
fn chains_at(
|
||||
service: &StructureService,
|
||||
snap: &Snapshot,
|
||||
frame: &StackFrame,
|
||||
top: bool,
|
||||
backend: bool,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<Vec<Candidate>> {
|
||||
let path = frame.path.as_ref().map(|p| p.0.as_path());
|
||||
let file_stem = path.and_then(Path::file_stem).and_then(|s| s.to_str()).unwrap_or_default();
|
||||
let stop = StopContext { line: frame.line, in_lambda: frame.name.contains("lambda$"), file_stem };
|
||||
let found = find_chains(service, snap, &stop, cancel)?;
|
||||
let mut candidates: Vec<Candidate> = found
|
||||
.chains
|
||||
.into_iter()
|
||||
.map(|chain| {
|
||||
let reason = refusal(&chain, frame.line, top, backend);
|
||||
let info = StreamChainInfo {
|
||||
index: 0,
|
||||
range: chain.range,
|
||||
text: chain.text.clone(),
|
||||
steps: chain.ops.iter().map(|op| op.name.clone()).collect(),
|
||||
terminal: chain.terminal.name.clone(),
|
||||
available: reason.is_none(),
|
||||
reason,
|
||||
};
|
||||
Candidate { info, chain: Some(chain) }
|
||||
})
|
||||
.collect();
|
||||
candidates.extend(found.rejected.into_iter().map(|rejected| {
|
||||
let reason = if top { rejection(rejected.reason) } else { ChainUnavailable::NotTopFrame };
|
||||
let info = StreamChainInfo {
|
||||
index: 0,
|
||||
range: rejected.range,
|
||||
text: rejected.text,
|
||||
steps: Vec::new(),
|
||||
terminal: String::new(),
|
||||
available: false,
|
||||
reason: Some(reason),
|
||||
};
|
||||
Candidate { info, chain: None }
|
||||
}));
|
||||
candidates.sort_by_key(|c| c.info.range);
|
||||
for (i, c) in candidates.iter_mut().enumerate() {
|
||||
c.info.index = i as u32;
|
||||
}
|
||||
Ok(candidates)
|
||||
}
|
||||
|
||||
fn refusal(chain: &StreamChain, line: u32, top: bool, backend: bool) -> Option<ChainUnavailable> {
|
||||
if !top {
|
||||
return Some(ChainUnavailable::NotTopFrame);
|
||||
}
|
||||
// ECJ puts the first instruction of `T x =\n root…` on the root's line, not the
|
||||
// statement's; the bundle makes the final call from the line table.
|
||||
if line < chain.first_line || line > root_line(chain) {
|
||||
return Some(ChainUnavailable::NotAtChainStart);
|
||||
}
|
||||
if let Err(refused) = real_run_plan(chain) {
|
||||
return Some(refusal_reason(refused));
|
||||
}
|
||||
(!backend).then_some(ChainUnavailable::NoBackend)
|
||||
}
|
||||
|
||||
fn root_line(chain: &StreamChain) -> u32 {
|
||||
let before_root = chain.text.get(..chain.root.span.0).unwrap_or_default();
|
||||
chain.range.start.line + before_root.matches('\n').count() as u32
|
||||
}
|
||||
|
||||
fn refusal_reason(refused: RealRunRefusal) -> ChainUnavailable {
|
||||
match refused {
|
||||
RealRunRefusal::NotJavaStreamRoot { root } => ChainUnavailable::NotJavaStreamRoot { root },
|
||||
RealRunRefusal::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
|
||||
RealRunRefusal::NoTerminal => ChainUnavailable::NoTerminal,
|
||||
RealRunRefusal::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
|
||||
RealRunRefusal::InsideChainLambda => ChainUnavailable::InsideChainLambda,
|
||||
RealRunRefusal::SyntaxError => ChainUnavailable::SyntaxError,
|
||||
}
|
||||
}
|
||||
|
||||
fn rejection(rejected: Rejection) -> ChainUnavailable {
|
||||
match rejected {
|
||||
Rejection::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
|
||||
Rejection::NoTerminal => ChainUnavailable::NoTerminal,
|
||||
Rejection::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
|
||||
Rejection::InsideChainLambda => ChainUnavailable::InsideChainLambda,
|
||||
Rejection::SyntaxError => ChainUnavailable::SyntaxError,
|
||||
}
|
||||
}
|
||||
|
||||
/// The same reasons as the bundle's refusals, for a chain that stopped being traceable between
|
||||
/// [`debug_stream_chains`] and [`debug_stream_trace`].
|
||||
fn trace_unavailable(reason: ChainUnavailable, line: u32, chain: Option<&StreamChain>) -> TraceUnavailable {
|
||||
let unsupported = |detail: String| TraceUnavailable::Unsupported { detail };
|
||||
match reason {
|
||||
ChainUnavailable::NotAtChainStart => {
|
||||
let start = chain.map_or(String::new(), |c| format!(", the chain starts on line {}", c.first_line + 1));
|
||||
TraceUnavailable::NotAtChainStart { detail: format!("the stop is on line {}{start}", line + 1) }
|
||||
}
|
||||
ChainUnavailable::NoBackend => TraceUnavailable::NoBackend,
|
||||
ChainUnavailable::NotTopFrame => unsupported("only the top frame can be traced".into()),
|
||||
ChainUnavailable::InsideChainLambda => unsupported("the chain is already running".into()),
|
||||
ChainUnavailable::NotJavaStreamRoot { root } => {
|
||||
unsupported(format!("the stream {root} does not start in this statement"))
|
||||
}
|
||||
ChainUnavailable::LazyTerminal { op } => unsupported(format!("{op}() does not run the pipeline")),
|
||||
ChainUnavailable::NoTerminal => unsupported("the chain has no terminal operation".into()),
|
||||
ChainUnavailable::UnknownOperation { op } => unsupported(format!("unknown stream operation {op}()")),
|
||||
ChainUnavailable::SyntaxError => unsupported("the statement does not parse".into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn ready(
|
||||
chain_info: StreamChainInfo,
|
||||
chain: &StreamChain,
|
||||
plan: &RealRunPlan,
|
||||
collected: TraceCollected,
|
||||
generation: u64,
|
||||
resumed_stops: u32,
|
||||
) -> StreamTraceResult {
|
||||
let recording = TraceRecording {
|
||||
records: collected.records.iter().map(|(step, v)| Record { step: *step, value: trace_value(v) }).collect(),
|
||||
dropped: collected.dropped,
|
||||
terminal: match &collected.terminal {
|
||||
CollectedTerminal::Value(v) => TerminalOutcome::Value { value: trace_value(v) },
|
||||
CollectedTerminal::Void => TerminalOutcome::Void,
|
||||
CollectedTerminal::Threw(e) => TerminalOutcome::Threw { exception: trace_value(e) },
|
||||
},
|
||||
};
|
||||
let mut linked = link_trace(plan, &recording, collected.skipped_breakpoints);
|
||||
// A stream made parallel before the chain's statement, which the bundle found so at run time.
|
||||
if collected.sequentialized && !plan.sequentialize {
|
||||
linked.banners.push(TraceBanner::Sequentialized);
|
||||
}
|
||||
if resumed_stops > 0 {
|
||||
linked.banners.push(TraceBanner::BreakpointsResumed { count: resumed_stops });
|
||||
}
|
||||
StreamTraceResult::Ready {
|
||||
chain: Box::new(chain_info),
|
||||
steps: recorded_steps(chain),
|
||||
records: collected.records.into_iter().map(|(step, value)| TraceRecordView { step, value }).collect(),
|
||||
links: linked.links,
|
||||
terminal: match collected.terminal {
|
||||
CollectedTerminal::Value(value) => TerminalView::Value { value },
|
||||
CollectedTerminal::Void => TerminalView::Void,
|
||||
CollectedTerminal::Threw(exception) => TerminalView::Threw { exception },
|
||||
},
|
||||
banners: linked.banners,
|
||||
generation,
|
||||
}
|
||||
}
|
||||
|
||||
fn trace_value(value: &JvmValue) -> TraceValue {
|
||||
match value {
|
||||
JvmValue::Null => TraceValue::Null,
|
||||
JvmValue::Boxed { id, type_name, text } => match box_kind(type_name) {
|
||||
Some(class) => TraceValue::Boxed { id: *id, class, value: text.clone() },
|
||||
None => TraceValue::Object { id: *id, class: type_name.clone() },
|
||||
},
|
||||
JvmValue::Str { id, text, .. } => {
|
||||
TraceValue::Str { id: *id, value: text.clone().unwrap_or_default(), truncated: text.is_none() }
|
||||
}
|
||||
JvmValue::Object { id, type_name } | JvmValue::Array { id, type_name, .. } => {
|
||||
TraceValue::Object { id: *id, class: type_name.clone() }
|
||||
}
|
||||
// The recorder boxes every element, so only a terminal's result is primitive, and linking
|
||||
// never reads that.
|
||||
JvmValue::Primitive { type_name, text } => match box_kind(type_name) {
|
||||
Some(class) => TraceValue::Boxed { id: 0, class, value: text.clone() },
|
||||
None => TraceValue::Null,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Wrapper class names (boxed values) and primitive type names (primitive values) alike.
|
||||
fn box_kind(type_name: &str) -> Option<BoxKind> {
|
||||
Some(match type_name {
|
||||
"java.lang.Boolean" | "boolean" => BoxKind::Boolean,
|
||||
"java.lang.Byte" | "byte" => BoxKind::Byte,
|
||||
"java.lang.Character" | "char" => BoxKind::Char,
|
||||
"java.lang.Short" | "short" => BoxKind::Short,
|
||||
"java.lang.Integer" | "int" => BoxKind::Int,
|
||||
"java.lang.Long" | "long" => BoxKind::Long,
|
||||
"java.lang.Float" | "float" => BoxKind::Float,
|
||||
"java.lang.Double" | "double" => BoxKind::Double,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("debug_stream_chains", |c| async move {
|
||||
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
|
||||
});
|
||||
d.add("debug_stream_trace", |c| async move {
|
||||
debug_stream_trace(
|
||||
&c.host,
|
||||
&c.window,
|
||||
c.arg("session")?,
|
||||
c.arg("request")?,
|
||||
c.arg("threadId")?,
|
||||
c.arg("frame")?,
|
||||
c.arg("chainIndex")?,
|
||||
c.arg("range")?,
|
||||
c.sender("onProgress")?,
|
||||
)
|
||||
.await
|
||||
});
|
||||
d.add("debug_stream_trace_abort", |c| async move {
|
||||
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,461 @@
|
||||
use super::*;
|
||||
use ide_core::{CancellationToken, LanguageId};
|
||||
use ide_language::{Syntax, SyntaxCache};
|
||||
use ide_streams::BoxKind;
|
||||
use serde_json::json;
|
||||
use std::sync::{Arc, OnceLock};
|
||||
|
||||
const SOURCE: &str = r#"import java.util.*;
|
||||
import java.util.stream.*;
|
||||
|
||||
class Chains {
|
||||
Stream<Integer> items;
|
||||
|
||||
void run(List<Integer> nums) {
|
||||
List<Integer> evens = nums.stream() // C_EVENS
|
||||
.filter(x -> x % 2 == 0) // C_EVENS_FILTER
|
||||
.collect(Collectors.toList());
|
||||
List<Integer> out = // C_DECL
|
||||
nums.stream() // C_ROOT
|
||||
.map(x -> x + 1) // C_ROOT_MAP
|
||||
.collect(Collectors.toList());
|
||||
long n = this.items.filter(x -> x > 0).count(); // C_FIELD
|
||||
Iterator<Integer> it = nums.stream().map(x -> x).iterator(); // C_LAZY
|
||||
List<String> a = nums.stream().filter(x -> x % 2 == 0).map(x -> x * 10 + 1).sorted().map(String::valueOf).collect(Collectors.toList()); // C_SPIKE
|
||||
}
|
||||
}
|
||||
"#;
|
||||
|
||||
fn service() -> &'static StructureService {
|
||||
static S: OnceLock<StructureService> = OnceLock::new();
|
||||
S.get_or_init(|| StructureService::new(Arc::new(SyntaxCache::new(Arc::new(Syntax::new())))))
|
||||
}
|
||||
|
||||
fn line_of(marker: &str) -> u32 {
|
||||
let tag = format!("// {marker}");
|
||||
let found = SOURCE.lines().position(|l| l.trim_end().ends_with(&tag));
|
||||
found.unwrap_or_else(|| panic!("no line marked {marker}")) as u32
|
||||
}
|
||||
|
||||
fn frame(line: u32) -> StackFrame {
|
||||
StackFrame {
|
||||
id: 1,
|
||||
name: "Chains.run(List)".into(),
|
||||
path: Some("/project/src/Chains.java".into()),
|
||||
line,
|
||||
column: 8,
|
||||
presentation_hint: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn chains_on(line: u32, top: bool, backend: bool) -> Vec<StreamChainInfo> {
|
||||
let java = LanguageId::new("java");
|
||||
let snap = Snapshot::text(&java, SOURCE);
|
||||
let found = chains_at(service(), &snap, &frame(line), top, backend, &CancellationToken::new()).expect("search");
|
||||
found.into_iter().map(|c| c.info).collect()
|
||||
}
|
||||
|
||||
fn availability(info: &StreamChainInfo) -> serde_json::Value {
|
||||
let mut v = serde_json::to_value(info).unwrap();
|
||||
let map = v.as_object_mut().unwrap();
|
||||
json!({ "available": map.remove("available"), "reason": map.remove("reason") })
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chains_refuse_non_top_frame() {
|
||||
let infos = chains_on(line_of("C_EVENS"), false, true);
|
||||
assert!(!infos.is_empty());
|
||||
for info in &infos {
|
||||
assert_eq!(availability(info), json!({"available": false, "reason": {"kind": "notTopFrame"}}), "{info:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chains_need_first_line() {
|
||||
let infos = chains_on(line_of("C_EVENS_FILTER"), true, true);
|
||||
assert_eq!(infos.len(), 1, "{infos:?}");
|
||||
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
|
||||
let mid = chains_on(line_of("C_ROOT_MAP"), true, true);
|
||||
assert_eq!(availability(&mid[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
|
||||
}
|
||||
|
||||
/// ECJ puts a declaration's first instruction on the line of its initializer's root call.
|
||||
#[test]
|
||||
fn chains_accept_the_root_line_of_a_declaration() {
|
||||
let at_root = chains_on(line_of("C_ROOT"), true, true);
|
||||
assert_eq!(at_root.len(), 1, "{at_root:?}");
|
||||
assert_eq!(availability(&at_root[0]), json!({"available": true, "reason": null}));
|
||||
let at_head = chains_on(line_of("C_DECL"), true, true);
|
||||
assert_eq!(availability(&at_head[0]), json!({"available": true, "reason": null}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chains_list_rejections() {
|
||||
let field = chains_on(line_of("C_FIELD"), true, true);
|
||||
assert_eq!(field.len(), 1, "{field:?}");
|
||||
assert_eq!(
|
||||
availability(&field[0]),
|
||||
json!({"available": false, "reason": {"kind": "notJavaStreamRoot", "root": "this.items"}})
|
||||
);
|
||||
let lazy = chains_on(line_of("C_LAZY"), true, true);
|
||||
assert_eq!(lazy.len(), 1, "{lazy:?}");
|
||||
assert_eq!(
|
||||
availability(&lazy[0]),
|
||||
json!({"available": false, "reason": {"kind": "lazyTerminal", "op": "iterator"}})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chains_without_a_tracer_have_no_backend() {
|
||||
let infos = chains_on(line_of("C_EVENS"), true, false);
|
||||
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "noBackend"}}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_info_json_shape() {
|
||||
let infos = chains_on(line_of("C_EVENS"), true, true);
|
||||
let v = serde_json::to_value(&infos[0]).unwrap();
|
||||
assert_eq!(v["index"], 0);
|
||||
assert_eq!(v["steps"], json!(["filter"]));
|
||||
assert_eq!(v["terminal"], "collect");
|
||||
assert_eq!(v["range"]["start"]["line"], line_of("C_EVENS"));
|
||||
assert_eq!(v["available"], true);
|
||||
assert!(v.get("reason").is_none(), "{v}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jvm_value_to_trace_value() {
|
||||
let boxed = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
|
||||
assert_eq!(trace_value(&boxed), TraceValue::Boxed { id: 4, class: BoxKind::Int, value: "8".into() });
|
||||
let long_text = JvmValue::Str { id: 5, text: None, length: 50_000 };
|
||||
assert_eq!(trace_value(&long_text), TraceValue::Str { id: 5, value: String::new(), truncated: true });
|
||||
let short_text = JvmValue::Str { id: 6, text: Some("81".into()), length: 2 };
|
||||
assert_eq!(trace_value(&short_text), TraceValue::Str { id: 6, value: "81".into(), truncated: false });
|
||||
let object = JvmValue::Object { id: 7, type_name: "com.x.Order".into() };
|
||||
assert_eq!(trace_value(&object), TraceValue::Object { id: 7, class: "com.x.Order".into() });
|
||||
let array = JvmValue::Array { id: 8, type_name: "int[]".into(), length: 3 };
|
||||
assert_eq!(trace_value(&array), TraceValue::Object { id: 8, class: "int[]".into() });
|
||||
assert_eq!(trace_value(&JvmValue::Null), TraceValue::Null);
|
||||
let odd_box = JvmValue::Boxed { id: 9, type_name: "java.math.BigInteger".into(), text: "1".into() };
|
||||
assert_eq!(trace_value(&odd_box), TraceValue::Object { id: 9, class: "java.math.BigInteger".into() });
|
||||
let count = JvmValue::Primitive { type_name: "long".into(), text: "4".into() };
|
||||
assert_eq!(trace_value(&count), TraceValue::Boxed { id: 0, class: BoxKind::Long, value: "4".into() });
|
||||
let odd_primitive = JvmValue::Primitive { type_name: "void".into(), text: String::new() };
|
||||
assert_eq!(trace_value(&odd_primitive), TraceValue::Null);
|
||||
}
|
||||
|
||||
/// The log measured on `source -> filter -> map -> sorted -> map` (see ide-streams' spike test),
|
||||
/// as the bundle reports it: every `peek` re-boxes, so no two boxes share an id.
|
||||
fn spike_collected() -> TraceCollected {
|
||||
let steps_values: [(u16, &str); 24] = [
|
||||
(0, "5"),
|
||||
(0, "3"),
|
||||
(0, "8"),
|
||||
(1, "8"),
|
||||
(2, "81"),
|
||||
(0, "1"),
|
||||
(0, "4"),
|
||||
(1, "4"),
|
||||
(2, "41"),
|
||||
(0, "2"),
|
||||
(1, "2"),
|
||||
(2, "21"),
|
||||
(0, "9"),
|
||||
(0, "6"),
|
||||
(1, "6"),
|
||||
(2, "61"),
|
||||
(3, "21"),
|
||||
(4, "21"),
|
||||
(3, "41"),
|
||||
(4, "41"),
|
||||
(3, "61"),
|
||||
(4, "61"),
|
||||
(3, "81"),
|
||||
(4, "81"),
|
||||
];
|
||||
let records = steps_values
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, &(step, text))| {
|
||||
let id = 100 + i as u64;
|
||||
let value = if step == 4 {
|
||||
JvmValue::Str { id, text: Some(text.into()), length: text.len() as u32 }
|
||||
} else {
|
||||
JvmValue::Boxed { id, type_name: "java.lang.Integer".into(), text: text.into() }
|
||||
};
|
||||
(step, value)
|
||||
})
|
||||
.collect();
|
||||
TraceCollected {
|
||||
records,
|
||||
dropped: 3,
|
||||
terminal: CollectedTerminal::Value(JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() }),
|
||||
skipped_breakpoints: 2,
|
||||
sequentialized: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ready_links_the_collected_records() {
|
||||
let java = LanguageId::new("java");
|
||||
let snap = Snapshot::text(&java, SOURCE);
|
||||
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
|
||||
let Candidate { info, chain } = found.into_iter().next().unwrap();
|
||||
let chain = chain.unwrap();
|
||||
let plan = real_run_plan(&chain).unwrap();
|
||||
let collected = spike_collected();
|
||||
let expected_records: Vec<TraceRecordView> =
|
||||
collected.records.iter().map(|(step, value)| TraceRecordView { step: *step, value: value.clone() }).collect();
|
||||
|
||||
let StreamTraceResult::Ready { chain: shown, steps, records, links, terminal, banners, generation } =
|
||||
ready(info.clone(), &chain, &plan, collected, 9, 0)
|
||||
else {
|
||||
panic!("not ready");
|
||||
};
|
||||
assert_eq!(*shown, info);
|
||||
assert_eq!(steps, ["stream", "filter", "map", "sorted", "map"]);
|
||||
assert_eq!(records, expected_records);
|
||||
assert_eq!(links.len(), records.len());
|
||||
assert_eq!(links[0], Link { parent: None, ambiguous: false });
|
||||
// `1=8` comes from the `0=8` just before it, and `2=81` from that.
|
||||
assert_eq!(links[3].parent, Some(2));
|
||||
assert_eq!(links[4].parent, Some(3));
|
||||
// `sorted` emits `3=21` after the whole upstream ran: it is the `2=21` of record 11, linked by
|
||||
// value although the box was re-made.
|
||||
assert_eq!(links[16], Link { parent: Some(11), ambiguous: false });
|
||||
assert_eq!(links[17].parent, Some(16));
|
||||
assert_eq!(links[22].parent, Some(4));
|
||||
assert_eq!(
|
||||
terminal,
|
||||
TerminalView::Value { value: JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() } }
|
||||
);
|
||||
assert_eq!(banners, [TraceBanner::Truncated { dropped: 3 }, TraceBanner::BreakpointsSkipped { count: 2 }]);
|
||||
assert_eq!(generation, 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ready_says_how_many_stops_were_resumed() {
|
||||
let java = LanguageId::new("java");
|
||||
let snap = Snapshot::text(&java, SOURCE);
|
||||
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
|
||||
let Candidate { info, chain } = found.into_iter().next().unwrap();
|
||||
let chain = chain.unwrap();
|
||||
let plan = real_run_plan(&chain).unwrap();
|
||||
|
||||
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, spike_collected(), 9, 3) else {
|
||||
panic!("not ready");
|
||||
};
|
||||
assert_eq!(
|
||||
banners,
|
||||
[
|
||||
TraceBanner::Truncated { dropped: 3 },
|
||||
TraceBanner::BreakpointsSkipped { count: 2 },
|
||||
TraceBanner::BreakpointsResumed { count: 3 }
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
const WINDOW: &str = "main";
|
||||
|
||||
/// A real `Host` with a trusted project holding `src/Chains.java` (= [`SOURCE`]).
|
||||
struct Fixture {
|
||||
host: Host,
|
||||
source: std::path::PathBuf,
|
||||
_temp: tempfile::TempDir,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
async fn new() -> Self {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(root.join("src")).unwrap();
|
||||
let source = root.join("src/Chains.java");
|
||||
std::fs::write(&source, SOURCE).unwrap();
|
||||
let host = Host::new(crate::HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(|_| {})),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.open_project(WINDOW, &root).unwrap();
|
||||
host.set_project_trust(&root, true, false).await.unwrap();
|
||||
Self { host, source, _temp: temp }
|
||||
}
|
||||
|
||||
fn frame(&self, line: u32) -> StackFrame {
|
||||
StackFrame { path: Some(self.source.as_path().into()), ..frame(line) }
|
||||
}
|
||||
|
||||
async fn chains(&self, frame: StackFrame) -> Vec<StreamChainInfo> {
|
||||
candidates(&self.host, WINDOW, frame, true, true).await.unwrap().into_iter().map(|c| c.info).collect()
|
||||
}
|
||||
|
||||
async fn trace(&self, request: u32, frame: StackFrame, index: u32, range: Range) -> StreamTraceResult {
|
||||
let request = RequestId(request);
|
||||
debug_stream_trace(
|
||||
&self.host,
|
||||
WINDOW,
|
||||
DebugSessionId(404),
|
||||
request,
|
||||
1,
|
||||
frame,
|
||||
index,
|
||||
range,
|
||||
Channel::new(|_| {}),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn chains_skip_frames_without_a_readable_java_source() {
|
||||
let f = Fixture::new().await;
|
||||
assert_eq!(f.chains(f.frame(line_of("C_EVENS"))).await.len(), 1, "the file on disk is read");
|
||||
let library = StackFrame {
|
||||
path: Some("jdt://contents/rt.jar/java.util.stream/ReferencePipeline.class?=java/rt.jar".into()),
|
||||
..frame(120)
|
||||
};
|
||||
assert_eq!(f.chains(library).await, []);
|
||||
let missing = StackFrame { path: Some(f.source.with_file_name("Missing.java").as_path().into()), ..frame(3) };
|
||||
assert_eq!(f.chains(missing).await, []);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn trace_refuses_a_chain_that_changed() {
|
||||
let f = Fixture::new().await;
|
||||
let at = f.frame(line_of("C_EVENS"));
|
||||
let listed = f.chains(at.clone()).await.remove(0);
|
||||
let changed = StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() };
|
||||
let mut moved = listed.range;
|
||||
moved.end.col += 1;
|
||||
assert_eq!(f.trace(1, at.clone(), listed.index, moved).await, changed);
|
||||
assert_eq!(f.trace(2, at, listed.index + 1, listed.range).await, changed);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn trace_reports_an_unavailable_chain_like_the_bundle() {
|
||||
let f = Fixture::new().await;
|
||||
let mid = f.frame(line_of("C_EVENS_FILTER"));
|
||||
let listed = f.chains(mid.clone()).await.remove(0);
|
||||
let detail = format!(
|
||||
"the stop is on line {}, the chain starts on line {}",
|
||||
line_of("C_EVENS_FILTER") + 1,
|
||||
line_of("C_EVENS") + 1
|
||||
);
|
||||
assert_eq!(
|
||||
f.trace(1, mid, listed.index, listed.range).await,
|
||||
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail } }
|
||||
);
|
||||
let field = f.frame(line_of("C_FIELD"));
|
||||
let listed = f.chains(field.clone()).await.remove(0);
|
||||
let detail = "the stream this.items does not start in this statement".to_string();
|
||||
assert_eq!(
|
||||
f.trace(2, field, listed.index, listed.range).await,
|
||||
StreamTraceResult::Unavailable { reason: TraceUnavailable::Unsupported { detail } }
|
||||
);
|
||||
}
|
||||
|
||||
/// The session id names no session: reaching `stream_trace` would fail the call.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn trace_cancelled_before_it_starts_does_not_run() {
|
||||
let f = Fixture::new().await;
|
||||
let at = f.frame(line_of("C_EVENS"));
|
||||
let listed = f.chains(at.clone()).await.remove(0);
|
||||
f.host.cancel_request(RequestId(7));
|
||||
assert_eq!(
|
||||
f.trace(7, at, listed.index, listed.range).await,
|
||||
StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() }
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::to_value(StreamTraceResult::Cancelled { detail: "x".into() }).unwrap(),
|
||||
json!({"status": "cancelled", "detail": "x"})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ready_result_json_shape() {
|
||||
let info = chains_on(line_of("C_EVENS"), true, true).remove(0);
|
||||
let value = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
|
||||
let ready = StreamTraceResult::Ready {
|
||||
chain: Box::new(info),
|
||||
steps: vec!["stream".into(), "filter".into()],
|
||||
records: vec![TraceRecordView { step: 0, value: value.clone() }],
|
||||
links: vec![Link { parent: None, ambiguous: false }],
|
||||
terminal: TerminalView::Threw { exception: JvmValue::Object { id: 9, type_name: "java.lang.X".into() } },
|
||||
banners: vec![TraceBanner::Truncated { dropped: 2 }, TraceBanner::BreakpointsSkipped { count: 1 }],
|
||||
generation: 3,
|
||||
};
|
||||
let v = serde_json::to_value(&ready).unwrap();
|
||||
assert_eq!(v["status"], "ready");
|
||||
assert_eq!(v["chain"]["available"], true);
|
||||
assert_eq!(v["steps"], json!(["stream", "filter"]));
|
||||
assert_eq!(
|
||||
v["records"],
|
||||
json!([{"step": 0, "value": {"kind": "boxed", "id": 4, "typeName": "java.lang.Integer", "text": "8"}}])
|
||||
);
|
||||
assert_eq!(v["links"], json!([{"parent": null, "ambiguous": false}]));
|
||||
assert_eq!(
|
||||
v["terminal"],
|
||||
json!({"kind": "threw", "exception": {"kind": "object", "id": 9, "typeName": "java.lang.X"}})
|
||||
);
|
||||
assert_eq!(v["banners"], json!([{"kind": "truncated", "dropped": 2}, {"kind": "breakpointsSkipped", "count": 1}]));
|
||||
assert_eq!(v["generation"], 3);
|
||||
assert_eq!(serde_json::to_value(TerminalView::Value { value }).unwrap()["kind"], "value");
|
||||
assert_eq!(serde_json::to_value(TerminalView::Void).unwrap(), json!({"kind": "void"}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn other_results_json_shape() {
|
||||
let unavailable =
|
||||
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "line 4".into() } };
|
||||
assert_eq!(
|
||||
serde_json::to_value(&unavailable).unwrap(),
|
||||
json!({"status": "unavailable", "reason": {"kind": "notAtChainStart", "detail": "line 4"}})
|
||||
);
|
||||
assert_eq!(
|
||||
serde_json::to_value(StreamTraceResult::Failed { detail: "boom".into() }).unwrap(),
|
||||
json!({"status": "failed", "detail": "boom"})
|
||||
);
|
||||
let progress = TraceProgress { phase: TracePhase::RecordingStopped, records: 5, dropped: 0, elapsed_ms: 40 };
|
||||
assert_eq!(
|
||||
serde_json::to_value(&progress).unwrap(),
|
||||
json!({"phase": "recordingStopped", "records": 5, "dropped": 0, "elapsedMs": 40})
|
||||
);
|
||||
let stuck = AbortState::Stuck { holders: vec![(3, "main".into())] };
|
||||
assert_eq!(serde_json::to_value(&stuck).unwrap(), json!({"kind": "stuck", "holders": [[3, "main"]]}));
|
||||
assert_eq!(serde_json::to_value(AbortState::Interrupted).unwrap(), json!({"kind": "interrupted"}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_info_steps_keep_modifiers() {
|
||||
let java = LanguageId::new("java");
|
||||
let source = "class Chains { void run(java.util.List<Integer> nums) {\n\
|
||||
long n = nums.parallelStream().filter(x -> x > 0).unordered().map(x -> x).count();\n} }";
|
||||
let snap = Snapshot::text(&java, source);
|
||||
let found = chains_at(service(), &snap, &frame(1), true, true, &CancellationToken::new()).unwrap();
|
||||
assert_eq!(found[0].info.steps, ["filter", "unordered", "map"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ready_says_a_stream_found_parallel_at_run_time_ran_sequentially() {
|
||||
let java = LanguageId::new("java");
|
||||
let snap = Snapshot::text(&java, SOURCE);
|
||||
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
|
||||
let Candidate { info, chain } = found.into_iter().next().unwrap();
|
||||
let chain = chain.unwrap();
|
||||
let plan = real_run_plan(&chain).unwrap();
|
||||
assert!(!plan.sequentialize);
|
||||
|
||||
let collected = TraceCollected { sequentialized: true, ..spike_collected() };
|
||||
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, collected, 9, 0) else {
|
||||
panic!("not ready");
|
||||
};
|
||||
assert!(banners.contains(&TraceBanner::Sequentialized), "{banners:?}");
|
||||
}
|
||||
@@ -1304,6 +1304,25 @@ pub async fn vcs_create_patch(
|
||||
.await
|
||||
}
|
||||
|
||||
/// The changes a commit with `options` would make in `repo`, as one patch (what Commit
|
||||
/// commits: the index with the selection applied, partial files' chosen hunks only).
|
||||
pub async fn vcs_pending_patch(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
repo: Option<PathBuf>,
|
||||
options: CommitOptions,
|
||||
) -> IdeResult<String> {
|
||||
const MAX_PATCH: usize = 1 << 20;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
project.with_repo_at(repo.as_deref(), |r| {
|
||||
let changes = r.pending_changes(&options, MAX_PATCH, &|path| project.vcs_encoding(path, None))?;
|
||||
Ok(changes.into_iter().filter_map(|c| c.diff).collect())
|
||||
})
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn vcs_patch_preview(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
@@ -1663,6 +1682,9 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("vcs_create_patch", |c| async move {
|
||||
vcs_create_patch(&c.host, &c.window, c.arg("repo")?, c.arg("source")?).await
|
||||
});
|
||||
d.add("vcs_pending_patch", |c| async move {
|
||||
vcs_pending_patch(&c.host, &c.window, c.arg("repo")?, c.arg("options")?).await
|
||||
});
|
||||
d.add("vcs_patch_preview", |c| async move {
|
||||
vcs_patch_preview(&c.host, &c.window, c.arg("repo")?, c.arg("patch")?).await
|
||||
});
|
||||
|
||||
@@ -112,6 +112,11 @@ pub trait PluginWorkspace: Send + Sync {
|
||||
) -> Result<serde_json::Value, HostError> {
|
||||
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
|
||||
}
|
||||
/// What the IDE has resolved of the Maven / Gradle builds of the project at `root`;
|
||||
/// never runs a build tool.
|
||||
fn build_graph(&self, _root: &Path) -> Result<super::BuildGraph, HostError> {
|
||||
Ok(super::BuildGraph::default())
|
||||
}
|
||||
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
|
||||
fn symbols(
|
||||
&self,
|
||||
@@ -1551,13 +1556,8 @@ impl HostApi for PluginApi {
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn open_diff(
|
||||
&self,
|
||||
client: &str,
|
||||
diff: ide_plugin::ContentDiff,
|
||||
file_name: Option<String>,
|
||||
) -> Result<(), HostError> {
|
||||
super::execution::validate_diff(&diff)?;
|
||||
fn open_diff(&self, client: &str, diff: ide_plugin::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
|
||||
super::execution::validate_file_diff(&diff)?;
|
||||
if let Some(name) = &file_name {
|
||||
super::execution::label(name, 256)?;
|
||||
}
|
||||
@@ -2229,6 +2229,20 @@ impl HostApi for PluginApi {
|
||||
Ok(result.to_string())
|
||||
}
|
||||
|
||||
fn build_dependencies(
|
||||
&self,
|
||||
root: &Path,
|
||||
module: Option<&str>,
|
||||
) -> Result<Vec<ide_plugin::DependencyNode>, HostError> {
|
||||
self.require_api("`build`", 10)?;
|
||||
let workspace = self.shared.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
|
||||
// The graph comes from running the project's build, as `vcs.read` does git.
|
||||
if !workspace.trusted(root) {
|
||||
return Err(HostError::Denied("project is not trusted".into()));
|
||||
}
|
||||
super::build_graph::dependency_nodes(&workspace.build_graph(root)?, module)
|
||||
}
|
||||
|
||||
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
|
||||
let matcher = globset::GlobBuilder::new(glob)
|
||||
.literal_separator(true)
|
||||
@@ -3379,6 +3393,13 @@ impl PluginWorkspace for HostWorkspace {
|
||||
})
|
||||
}
|
||||
|
||||
fn build_graph(&self, root: &Path) -> Result<super::BuildGraph, HostError> {
|
||||
let host = self.0.upgrade().ok_or(HostError::Cancelled)?;
|
||||
let project = HostWorkspace::project_covering(self, root)
|
||||
.ok_or_else(|| HostError::NotFound("the project is no longer open".into()))?;
|
||||
crate::ops::build::analyzed_dependencies(&project, &host.config_dir, root).map_err(failed)
|
||||
}
|
||||
|
||||
fn trusted(&self, root: &Path) -> bool {
|
||||
// A workspace member is as trusted as the group's project it was opened with.
|
||||
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
|
||||
|
||||
@@ -0,0 +1,337 @@
|
||||
//! `build.dependencies`: the Dependency Analyzer's Maven / Gradle trees as the flat
|
||||
//! list the plugin API passes (records can't nest), each module a root.
|
||||
|
||||
use ide_build::{GradleDependency, GradleReport, MavenDependency, MavenProject, Omission};
|
||||
use ide_plugin::{DependencyNode, DependencyStatus, HostError};
|
||||
|
||||
/// Most nodes one call returns.
|
||||
const MAX_NODES: usize = 100_000;
|
||||
|
||||
/// What the IDE has resolved of a project's builds, without running a build tool.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct BuildGraph {
|
||||
/// Maven modules with their dependencies (with the transitive ones after a sync).
|
||||
pub maven: Vec<MavenProject>,
|
||||
pub gradle: Vec<GradleModule>,
|
||||
}
|
||||
|
||||
/// A Gradle project and the reports the Dependency Analyzer read for it.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct GradleModule {
|
||||
/// Gradle path (`:`, `:app`).
|
||||
pub path: String,
|
||||
/// One per configuration read.
|
||||
pub reports: Vec<GradleReport>,
|
||||
}
|
||||
|
||||
/// The graph of `module` (a Maven `groupId:artifactId` or a Gradle path), or of every module.
|
||||
pub fn dependency_nodes(graph: &BuildGraph, module: Option<&str>) -> Result<Vec<DependencyNode>, HostError> {
|
||||
let mut out = Nodes(Vec::new());
|
||||
let mut found = false;
|
||||
for p in graph.maven.iter().filter(|p| module.is_none_or(|m| m == p.key())) {
|
||||
found = true;
|
||||
let root = out.push(DependencyNode {
|
||||
group: p.group_id.clone(),
|
||||
artifact: p.artifact_id.clone(),
|
||||
version: p.version.clone(),
|
||||
scope: String::new(),
|
||||
status: DependencyStatus::Resolved,
|
||||
requested_version: None,
|
||||
parent: None,
|
||||
})?;
|
||||
out.maven(&p.dependencies, root)?;
|
||||
}
|
||||
for g in graph.gradle.iter().filter(|g| module.is_none_or(|m| m == g.path)) {
|
||||
found = true;
|
||||
let root = out.push(DependencyNode {
|
||||
group: String::new(),
|
||||
artifact: g.path.clone(),
|
||||
version: String::new(),
|
||||
scope: String::new(),
|
||||
status: DependencyStatus::Resolved,
|
||||
requested_version: None,
|
||||
parent: None,
|
||||
})?;
|
||||
for report in &g.reports {
|
||||
out.gradle(&report.dependencies, &report.configuration, root)?;
|
||||
}
|
||||
}
|
||||
match module {
|
||||
Some(m) if !found => Err(HostError::NotFound(format!("no Maven or Gradle module `{m}` in this project"))),
|
||||
_ => Ok(out.0),
|
||||
}
|
||||
}
|
||||
|
||||
struct Nodes(Vec<DependencyNode>);
|
||||
|
||||
impl Nodes {
|
||||
fn push(&mut self, node: DependencyNode) -> Result<u32, HostError> {
|
||||
if self.0.len() >= MAX_NODES {
|
||||
return Err(HostError::Failed(format!(
|
||||
"the dependency graph has more than {MAX_NODES} nodes; ask for one module"
|
||||
)));
|
||||
}
|
||||
self.0.push(node);
|
||||
Ok((self.0.len() - 1) as u32)
|
||||
}
|
||||
|
||||
fn maven(&mut self, deps: &[MavenDependency], parent: u32) -> Result<(), HostError> {
|
||||
for d in deps {
|
||||
let version = d.version.clone().unwrap_or_default();
|
||||
let (status, version, requested) = match d.omitted {
|
||||
// `version` lost to `conflict_with`.
|
||||
Some(Omission::Conflict) => (
|
||||
DependencyStatus::OmittedForConflict,
|
||||
d.conflict_with.clone().unwrap_or_else(|| version.clone()),
|
||||
Some(version),
|
||||
),
|
||||
Some(Omission::Duplicate | Omission::Cycle) => {
|
||||
(DependencyStatus::OmittedForDuplicate, version, d.managed_from.clone())
|
||||
}
|
||||
None if d.managed_from.is_some() => (DependencyStatus::VersionManaged, version, d.managed_from.clone()),
|
||||
None => (DependencyStatus::Resolved, version, None),
|
||||
};
|
||||
let index = self.push(DependencyNode {
|
||||
group: d.group_id.clone(),
|
||||
artifact: d.artifact_id.clone(),
|
||||
requested_version: requested.filter(|r| *r != version),
|
||||
version,
|
||||
scope: d.scope.clone(),
|
||||
status,
|
||||
parent: Some(parent),
|
||||
})?;
|
||||
self.maven(&d.children, index)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn gradle(&mut self, deps: &[GradleDependency], configuration: &str, parent: u32) -> Result<(), HostError> {
|
||||
// A constraint is not a dependency: it occurs as one elsewhere in the tree.
|
||||
for d in deps.iter().filter(|d| !d.constraint) {
|
||||
let (status, version, requested) = if d.project || d.unresolved {
|
||||
(DependencyStatus::Resolved, String::new(), None)
|
||||
} else {
|
||||
match (&d.requested, &d.selected) {
|
||||
(_, None) => (DependencyStatus::Resolved, d.requested.clone().unwrap_or_default(), None),
|
||||
// A platform or a constraint supplies the version.
|
||||
(None, Some(selected)) => (DependencyStatus::VersionManaged, selected.clone(), None),
|
||||
// Conflict resolution picked another version than this exact request.
|
||||
(Some(requested), Some(selected)) if exact_version(requested) => {
|
||||
(DependencyStatus::OmittedForConflict, selected.clone(), Some(requested.clone()))
|
||||
}
|
||||
// A range or a rich version (`1.+`, `{strictly 2.0}`) resolved as asked.
|
||||
(Some(requested), Some(selected)) => {
|
||||
(DependencyStatus::Resolved, selected.clone(), Some(requested.clone()))
|
||||
}
|
||||
}
|
||||
};
|
||||
let status = if d.repeated && status == DependencyStatus::Resolved {
|
||||
DependencyStatus::OmittedForDuplicate
|
||||
} else {
|
||||
status
|
||||
};
|
||||
let index = self.push(DependencyNode {
|
||||
group: d.group.clone(),
|
||||
artifact: d.name.clone(),
|
||||
requested_version: requested.filter(|r| *r != version),
|
||||
version,
|
||||
scope: configuration.to_owned(),
|
||||
status,
|
||||
parent: Some(parent),
|
||||
})?;
|
||||
self.gradle(&d.children, configuration, index)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// `1.2.3`, not a range, dynamic or rich version (`[1,2)`, `1.+`, `latest.release`, `{strictly 1}`).
|
||||
fn exact_version(v: &str) -> bool {
|
||||
!v.is_empty() && !v.starts_with("latest.") && !v.contains(['[', ']', '(', ')', ',', '+', '{', '}', ' '])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn maven(group: &str, artifact: &str, version: &str, scope: &str) -> MavenDependency {
|
||||
MavenDependency {
|
||||
group_id: group.into(),
|
||||
artifact_id: artifact.into(),
|
||||
version: Some(version.into()),
|
||||
kind: "jar".into(),
|
||||
scope: scope.into(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn gradle(group: &str, name: &str, requested: Option<&str>, selected: Option<&str>) -> GradleDependency {
|
||||
GradleDependency {
|
||||
group: group.into(),
|
||||
name: name.into(),
|
||||
requested: requested.map(Into::into),
|
||||
selected: selected.map(Into::into),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// (group, artifact, version, scope, status, requested, parent) of every node.
|
||||
type Row<'a> = (&'a str, &'a str, &'a str, &'a str, DependencyStatus, Option<&'a str>, Option<u32>);
|
||||
|
||||
fn rows(nodes: &[DependencyNode]) -> Vec<Row<'_>> {
|
||||
nodes
|
||||
.iter()
|
||||
.map(|n| {
|
||||
(
|
||||
n.group.as_str(),
|
||||
n.artifact.as_str(),
|
||||
n.version.as_str(),
|
||||
n.scope.as_str(),
|
||||
n.status,
|
||||
n.requested_version.as_deref(),
|
||||
n.parent,
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn graph() -> BuildGraph {
|
||||
let mut lang3_lost = maven("org.apache.commons", "commons-lang3", "3.12.0", "compile");
|
||||
lang3_lost.omitted = Some(Omission::Conflict);
|
||||
lang3_lost.conflict_with = Some("3.14.0".into());
|
||||
let mut text = maven("org.apache.commons", "commons-text", "1.11.0", "compile");
|
||||
text.children = vec![lang3_lost];
|
||||
let mut logging = maven("commons-logging", "commons-logging", "1.3.0", "compile");
|
||||
logging.managed_from = Some("1.2".into());
|
||||
let mut junit_again = maven("junit", "junit", "4.13.2", "test");
|
||||
junit_again.omitted = Some(Omission::Duplicate);
|
||||
let mut hamcrest = maven("org.hamcrest", "hamcrest", "2.2", "test");
|
||||
hamcrest.children = vec![junit_again];
|
||||
let app = MavenProject {
|
||||
group_id: "com.example".into(),
|
||||
artifact_id: "app".into(),
|
||||
version: "1.0".into(),
|
||||
dependencies: vec![
|
||||
maven("org.apache.commons", "commons-lang3", "3.14.0", "compile"),
|
||||
text,
|
||||
logging,
|
||||
hamcrest,
|
||||
],
|
||||
..Default::default()
|
||||
};
|
||||
let mut databind = gradle("com.fasterxml.jackson.core", "jackson-databind", Some("2.15.0"), Some("2.15.3"));
|
||||
databind.repeated = true;
|
||||
let mut web = gradle("org.springframework.boot", "spring-boot-starter-web", None, Some("3.2.0"));
|
||||
web.children = vec![databind];
|
||||
let mut constraint = gradle("com.google.guava", "guava", Some("32.1.3-jre"), None);
|
||||
constraint.constraint = true;
|
||||
let mut core = gradle("", ":core", None, None);
|
||||
core.project = true;
|
||||
core.children = vec![constraint];
|
||||
let mut failed = gradle("org.missing", "gone", Some("9"), None);
|
||||
failed.unresolved = true;
|
||||
let report = GradleReport {
|
||||
project: ":web".into(),
|
||||
configuration: "runtimeClasspath".into(),
|
||||
dependencies: vec![
|
||||
web,
|
||||
core,
|
||||
gradle("org.slf4j", "slf4j-api", Some("2.+"), Some("2.0.13")),
|
||||
gradle("org.yaml", "snakeyaml", Some("2.2"), None),
|
||||
failed,
|
||||
],
|
||||
};
|
||||
BuildGraph {
|
||||
maven: vec![app],
|
||||
gradle: vec![
|
||||
GradleModule { path: ":web".into(), reports: vec![report] },
|
||||
GradleModule { path: ":".into(), reports: Vec::new() },
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn modules_are_roots_with_their_trees_flattened_under_them() {
|
||||
use DependencyStatus::*;
|
||||
let nodes = dependency_nodes(&graph(), None).unwrap();
|
||||
assert_eq!(
|
||||
rows(&nodes),
|
||||
[
|
||||
("com.example", "app", "1.0", "", Resolved, None, None),
|
||||
("org.apache.commons", "commons-lang3", "3.14.0", "compile", Resolved, None, Some(0)),
|
||||
("org.apache.commons", "commons-text", "1.11.0", "compile", Resolved, None, Some(0)),
|
||||
(
|
||||
"org.apache.commons",
|
||||
"commons-lang3",
|
||||
"3.14.0",
|
||||
"compile",
|
||||
OmittedForConflict,
|
||||
Some("3.12.0"),
|
||||
Some(2)
|
||||
),
|
||||
("commons-logging", "commons-logging", "1.3.0", "compile", VersionManaged, Some("1.2"), Some(0)),
|
||||
("org.hamcrest", "hamcrest", "2.2", "test", Resolved, None, Some(0)),
|
||||
("junit", "junit", "4.13.2", "test", OmittedForDuplicate, None, Some(5)),
|
||||
("", ":web", "", "", Resolved, None, None),
|
||||
(
|
||||
"org.springframework.boot",
|
||||
"spring-boot-starter-web",
|
||||
"3.2.0",
|
||||
"runtimeClasspath",
|
||||
VersionManaged,
|
||||
None,
|
||||
Some(7)
|
||||
),
|
||||
(
|
||||
"com.fasterxml.jackson.core",
|
||||
"jackson-databind",
|
||||
"2.15.3",
|
||||
"runtimeClasspath",
|
||||
OmittedForConflict,
|
||||
Some("2.15.0"),
|
||||
Some(8)
|
||||
),
|
||||
("", ":core", "", "runtimeClasspath", Resolved, None, Some(7)),
|
||||
("org.slf4j", "slf4j-api", "2.0.13", "runtimeClasspath", Resolved, Some("2.+"), Some(7)),
|
||||
("org.yaml", "snakeyaml", "2.2", "runtimeClasspath", Resolved, None, Some(7)),
|
||||
("org.missing", "gone", "", "runtimeClasspath", Resolved, None, Some(7)),
|
||||
("", ":", "", "", Resolved, None, None),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_module_by_its_maven_key_or_gradle_path() {
|
||||
let maven = dependency_nodes(&graph(), Some("com.example:app")).unwrap();
|
||||
assert_eq!((maven.len(), maven[0].artifact.as_str()), (7, "app"));
|
||||
let gradle = dependency_nodes(&graph(), Some(":web")).unwrap();
|
||||
assert_eq!((gradle.len(), gradle[0].artifact.as_str(), gradle[1].parent), (7, ":web", Some(0)));
|
||||
// A Gradle project with no report read yet is known, with nothing under it.
|
||||
assert_eq!(dependency_nodes(&graph(), Some(":")).unwrap().len(), 1);
|
||||
let err = dependency_nodes(&graph(), Some("app")).unwrap_err();
|
||||
assert!(matches!(err, HostError::NotFound(_)), "{err:?}");
|
||||
assert!(dependency_nodes(&BuildGraph::default(), None).unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_graph_too_large_for_one_call_fails() {
|
||||
let app = MavenProject {
|
||||
group_id: "g".into(),
|
||||
artifact_id: "a".into(),
|
||||
dependencies: vec![maven("g", "d", "1", "compile"); MAX_NODES],
|
||||
..Default::default()
|
||||
};
|
||||
let graph = BuildGraph { maven: vec![app], gradle: Vec::new() };
|
||||
assert!(matches!(dependency_nodes(&graph, None), Err(HostError::Failed(_))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_versions() {
|
||||
for v in ["1.0", "32.1.3-jre", "2.15.0"] {
|
||||
assert!(exact_version(v), "{v}");
|
||||
}
|
||||
for v in ["", "1.+", "[1.0,2.0)", "latest.release", "{strictly 1.0}"] {
|
||||
assert!(!exact_version(v), "{v}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -91,12 +91,31 @@ fn diff_side(value: &str, side: &str) -> Result<(), HostError> {
|
||||
}
|
||||
|
||||
pub(super) fn validate_diff(diff: &ide_plugin::ContentDiff) -> Result<(), HostError> {
|
||||
diff_side(&diff.left, "left")?;
|
||||
diff_side(&diff.right, "right")?;
|
||||
for value in [&diff.left_label, &diff.right_label].into_iter().flatten() {
|
||||
validate_diff_parts([Some(&diff.left), Some(&diff.right)], [&diff.left_label, &diff.right_label], &diff.title)
|
||||
}
|
||||
|
||||
/// A `None` side doesn't exist (an added or deleted file); at least one side does.
|
||||
pub(super) fn validate_file_diff(diff: &ide_plugin::FileDiff) -> Result<(), HostError> {
|
||||
validate_diff_parts([diff.left.as_ref(), diff.right.as_ref()], [&diff.left_label, &diff.right_label], &diff.title)
|
||||
}
|
||||
|
||||
fn validate_diff_parts(
|
||||
sides: [Option<&String>; 2],
|
||||
labels: [&Option<String>; 2],
|
||||
title: &Option<String>,
|
||||
) -> Result<(), HostError> {
|
||||
if sides.iter().all(Option::is_none) {
|
||||
return Err(HostError::Invalid("a diff needs at least one side".into()));
|
||||
}
|
||||
for (value, side) in sides.into_iter().zip(["left", "right"]) {
|
||||
if let Some(value) = value {
|
||||
diff_side(value, side)?;
|
||||
}
|
||||
}
|
||||
for value in labels.into_iter().flatten() {
|
||||
label(value, 128)?;
|
||||
}
|
||||
if let Some(title) = &diff.title {
|
||||
if let Some(title) = title {
|
||||
label(title, 256)?;
|
||||
}
|
||||
Ok(())
|
||||
@@ -713,6 +732,28 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_file_diff_may_miss_one_side_but_not_both() {
|
||||
let side = |left: Option<&str>, right: Option<&str>| ide_plugin::FileDiff {
|
||||
left: left.map(Into::into),
|
||||
right: right.map(Into::into),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(validate_file_diff(&side(None, Some("added\n"))).is_ok());
|
||||
assert!(validate_file_diff(&side(Some("deleted\n"), None)).is_ok());
|
||||
assert!(validate_file_diff(&side(Some(""), Some(""))).is_ok());
|
||||
assert!(
|
||||
matches!(validate_file_diff(&side(None, None)), Err(HostError::Invalid(m)) if m == "a diff needs at least one side")
|
||||
);
|
||||
let huge = "y".repeat(MAX_DIFF_SIDE + 1);
|
||||
assert!(
|
||||
matches!(validate_file_diff(&side(None, Some(&huge))), Err(HostError::Invalid(m)) if m == "diff too large: the right side is over 8 MiB")
|
||||
);
|
||||
assert!(
|
||||
matches!(validate_file_diff(&side(Some("a\0"), None)), Err(HostError::Invalid(m)) if m.contains("NUL"))
|
||||
);
|
||||
}
|
||||
|
||||
fn launch(
|
||||
env: Vec<(&str, &str)>,
|
||||
debugger: Option<ide_plugin::PluginDebugger>,
|
||||
|
||||
@@ -0,0 +1,250 @@
|
||||
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
|
||||
//! JVM of Application, Spring Boot and JAR Application configurations.
|
||||
//!
|
||||
//! ```toml
|
||||
//! [[contributes.javaAgents]]
|
||||
//! path = "agent/openidea-spring-agent.jar" # inside the package
|
||||
//! args = "optional-arguments" # optional
|
||||
//! ```
|
||||
//!
|
||||
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
|
||||
//! capability; granting it records the jar's hash, and a launch adds the agent only
|
||||
//! while the jar still has it ([`ide_run::java_agent`]).
|
||||
|
||||
use ide_extension::{Capability, Disposable, ExtensionPoint, Manifest, Package, Placement, Prepared, decode};
|
||||
use ide_language::ProgramPin;
|
||||
use ide_run::java_agent::{ContributedAgent, JavaAgentSource};
|
||||
use parking_lot::RwLock;
|
||||
use serde::Deserialize;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
pub const POINT_ID: &str = "javaAgents";
|
||||
const MAX_ARGS: usize = 4096;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Decl {
|
||||
path: PathBuf,
|
||||
#[serde(default)]
|
||||
args: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Agent {
|
||||
/// The jar, resolved inside the package.
|
||||
jar: PathBuf,
|
||||
args: Option<String>,
|
||||
}
|
||||
|
||||
/// Agents of enabled plugins.
|
||||
#[derive(Default)]
|
||||
pub struct JavaAgents {
|
||||
items: RwLock<Vec<(u64, String, Agent)>>,
|
||||
seq: AtomicU64,
|
||||
}
|
||||
|
||||
impl JavaAgents {
|
||||
fn add(self: &Arc<Self>, plugin: String, agent: Agent) -> Disposable {
|
||||
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
|
||||
self.items.write().push((seq, plugin, agent));
|
||||
let weak = Arc::downgrade(self);
|
||||
Disposable::new(move || {
|
||||
if let Some(this) = weak.upgrade() {
|
||||
this.items.write().retain(|(s, _, _)| *s != seq);
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub struct JavaAgentsPoint {
|
||||
store: Arc<JavaAgents>,
|
||||
}
|
||||
|
||||
impl JavaAgentsPoint {
|
||||
pub fn new(store: Arc<JavaAgents>) -> Self {
|
||||
Self { store }
|
||||
}
|
||||
}
|
||||
|
||||
impl ExtensionPoint for JavaAgentsPoint {
|
||||
fn id(&self) -> &'static str {
|
||||
POINT_ID
|
||||
}
|
||||
|
||||
fn placement(&self) -> Placement {
|
||||
Placement::Workspace
|
||||
}
|
||||
|
||||
fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
|
||||
pkg.manifest.needs_api("contributes.javaAgents", 10)?;
|
||||
if pkg.manifest.declarations(POINT_ID).len() > 1 {
|
||||
return Err("contributes.javaAgents: a plugin contributes at most one Java agent".into());
|
||||
}
|
||||
let d: Decl = decode(POINT_ID, decl)?;
|
||||
let jar = resolve(&pkg.dir, &d.path)?;
|
||||
let args = d.args.filter(|a| !a.is_empty());
|
||||
if let Some(args) = &args
|
||||
&& (args.len() > MAX_ARGS || args.contains(|c: char| c.is_control()))
|
||||
{
|
||||
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
|
||||
}
|
||||
let label = label(&d.path, args.as_deref());
|
||||
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
|
||||
let agent = Agent { jar, args };
|
||||
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
|
||||
}
|
||||
}
|
||||
|
||||
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
|
||||
fn label(path: &Path, args: Option<&str>) -> String {
|
||||
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
|
||||
match args {
|
||||
Some(args) => format!("{name}={args}"),
|
||||
None => name,
|
||||
}
|
||||
}
|
||||
|
||||
/// The jar a package's declaration names, as an absolute path inside the package:
|
||||
/// `..`, absolute paths and symlinks that lead out of it are refused.
|
||||
fn resolve(dir: &Path, rel: &Path) -> Result<PathBuf, String> {
|
||||
ide_extension::check_relative(rel, "contributes.javaAgents: `path`")?;
|
||||
let root = dunce::canonicalize(dir).map_err(|e| format!("plugin directory: {e}"))?;
|
||||
let jar = dunce::canonicalize(dir.join(rel))
|
||||
.map_err(|_| format!("contributes.javaAgents: {}: no such file in the plugin", rel.display()))?;
|
||||
if !jar.starts_with(&root) {
|
||||
return Err(format!("contributes.javaAgents: {}: points outside the plugin", rel.display()));
|
||||
}
|
||||
if !jar.is_file() {
|
||||
return Err(format!("contributes.javaAgents: {}: not a file", rel.display()));
|
||||
}
|
||||
Ok(jar)
|
||||
}
|
||||
|
||||
/// The jar the package at `dir` declares, for recording its hash when `java.agent`
|
||||
/// is granted (before the declaration has taken effect, as on install).
|
||||
pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
|
||||
let decl = manifest.declarations(POINT_ID).into_iter().next()?;
|
||||
let d: Decl = decode(POINT_ID, decl).ok()?;
|
||||
resolve(dir, &d.path).ok()
|
||||
}
|
||||
|
||||
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
|
||||
|
||||
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
|
||||
pub struct PluginJavaAgents {
|
||||
pub(super) store: Arc<JavaAgents>,
|
||||
pub(super) pins: Pins,
|
||||
}
|
||||
|
||||
impl JavaAgentSource for PluginJavaAgents {
|
||||
fn agents(&self) -> Vec<ContributedAgent> {
|
||||
let cap = Capability::JavaAgent.to_string();
|
||||
let pins = self.pins.read();
|
||||
self.store
|
||||
.items
|
||||
.read()
|
||||
.iter()
|
||||
.map(|(_, plugin, agent)| ContributedAgent {
|
||||
plugin: plugin.clone(),
|
||||
jar: agent.jar.clone(),
|
||||
args: agent.args.clone(),
|
||||
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const MANIFEST: &str =
|
||||
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
|
||||
|
||||
fn package(dir: &Path, manifest: &str) -> Package {
|
||||
std::fs::create_dir_all(dir.join("agent")).unwrap();
|
||||
std::fs::write(dir.join("agent/spring agent.jar"), b"PK").unwrap();
|
||||
Package::new(Manifest::parse(manifest).unwrap(), dir.to_path_buf())
|
||||
}
|
||||
|
||||
fn prepare(pkg: &Package) -> Result<Prepared, String> {
|
||||
let point = JavaAgentsPoint::new(Arc::default());
|
||||
let decls = pkg.manifest.declarations(POINT_ID);
|
||||
let mut last = Err("no declaration".into());
|
||||
for decl in decls {
|
||||
last = Ok(point.prepare(pkg, decl)?);
|
||||
}
|
||||
last
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_the_declaration_and_derives_the_capability() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let toml = format!(
|
||||
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"port=0,trace\"\n"
|
||||
);
|
||||
let pkg = package(tmp.path(), &toml);
|
||||
let prepared = prepare(&pkg).unwrap();
|
||||
assert_eq!(prepared.capabilities, [Capability::JavaAgent]);
|
||||
assert_eq!(prepared.files, [PathBuf::from("agent/spring agent.jar")]);
|
||||
assert_eq!(prepared.label, "spring agent.jar=port=0,trace");
|
||||
let jar = declared_jar(&pkg.manifest, &pkg.dir).unwrap();
|
||||
assert_eq!(jar, dunce::canonicalize(tmp.path().join("agent/spring agent.jar")).unwrap());
|
||||
|
||||
let store: Arc<JavaAgents> = Arc::default();
|
||||
let point = JavaAgentsPoint::new(store.clone());
|
||||
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
|
||||
let disposable = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
|
||||
let source = PluginJavaAgents { store: store.clone(), pins: Arc::default() };
|
||||
let agents = source.agents();
|
||||
assert_eq!(agents.len(), 1);
|
||||
assert_eq!(
|
||||
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
|
||||
("acme.spring", Some("port=0,trace"), None)
|
||||
);
|
||||
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
|
||||
assert!(source.agents()[0].approved_hash.is_some());
|
||||
disposable.dispose();
|
||||
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_what_would_fail_at_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let outside = tempfile::tempdir().unwrap();
|
||||
std::fs::write(outside.path().join("evil.jar"), b"PK").unwrap();
|
||||
let refused = |n: usize, manifest: &str| {
|
||||
let dir = tmp.path().join(n.to_string());
|
||||
prepare(&package(&dir, manifest)).map(|_| ()).unwrap_err()
|
||||
};
|
||||
let case = |n: usize, body: &str| refused(n, &format!("{MANIFEST}{body}"));
|
||||
let agent = |path: &str| format!("[[contributes.javaAgents]]\npath = \"{path}\"\n");
|
||||
assert!(case(0, &agent("../evil.jar")).contains("relative path inside the plugin"));
|
||||
assert!(case(1, &agent("/etc/passwd")).contains("relative path inside the plugin"));
|
||||
assert!(case(2, &agent("agent/missing.jar")).contains("no such file"));
|
||||
assert!(case(3, &agent("agent")).contains("not a file"));
|
||||
let two = format!("{}{}", agent("agent/spring agent.jar"), agent("agent/spring agent.jar"));
|
||||
assert!(case(4, &two).contains("at most one Java agent"));
|
||||
assert!(
|
||||
case(5, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"a\\nb\"\n")
|
||||
.contains("one line")
|
||||
);
|
||||
assert!(
|
||||
case(6, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nmain = \"x\"\n")
|
||||
.contains("unknown field")
|
||||
);
|
||||
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
|
||||
assert!(refused(7, &old).contains("new in plugin API 1.10"));
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let dir = tmp.path().join("8");
|
||||
let pkg = package(&dir, &format!("{MANIFEST}{}", agent("agent/link.jar")));
|
||||
std::os::unix::fs::symlink(outside.path().join("evil.jar"), dir.join("agent/link.jar")).unwrap();
|
||||
assert!(prepare(&pkg).map(|_| ()).unwrap_err().contains("points outside the plugin"));
|
||||
assert_eq!(declared_jar(&pkg.manifest, &pkg.dir), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,7 @@
|
||||
|
||||
mod api;
|
||||
mod auth;
|
||||
mod build_graph;
|
||||
pub mod commands;
|
||||
pub mod commit;
|
||||
mod database;
|
||||
@@ -37,6 +38,7 @@ mod inlay_hints;
|
||||
mod install;
|
||||
pub mod intellij;
|
||||
mod ipc;
|
||||
mod java_agents;
|
||||
pub mod language_features;
|
||||
mod market;
|
||||
mod mcp;
|
||||
@@ -58,6 +60,7 @@ pub mod web;
|
||||
mod websocket;
|
||||
|
||||
pub use api::{FileSecretStore, HostWorkspace, PluginWorkspace, SecretStore};
|
||||
pub use build_graph::{BuildGraph, GradleModule};
|
||||
pub(crate) use hover::merge as merge_hover;
|
||||
pub use icons::{
|
||||
MAX_PLUGIN_ICON, map_asset as icon_theme_map_asset, plugin_icon, sanitize_svg, svg_prefix as icon_theme_svg_prefix,
|
||||
@@ -378,6 +381,8 @@ pub struct PluginHost {
|
||||
ui: Arc<UiStore>,
|
||||
languages: Arc<PluginLanguages>,
|
||||
run_detectors: Arc<run_detectors::RunDetectors>,
|
||||
/// `[[contributes.javaAgents]]` of enabled plugins.
|
||||
java_agents: Arc<java_agents::JavaAgents>,
|
||||
/// `[[contributes.providers]]` of enabled plugins.
|
||||
providers: Arc<providers::Providers>,
|
||||
navigation: Mutex<navigation::NavigationIndex>,
|
||||
@@ -457,7 +462,9 @@ impl PluginHost {
|
||||
let languages = PluginLanguages::new();
|
||||
let run_detectors: Arc<run_detectors::RunDetectors> = Arc::default();
|
||||
let providers: Arc<providers::Providers> = Arc::default();
|
||||
register_builtin_points(®istry, &ui, &languages, &run_detectors, &providers).map_err(IdeError::internal)?;
|
||||
let java_agents: Arc<java_agents::JavaAgents> = Arc::default();
|
||||
register_builtin_points(®istry, &ui, &languages, &run_detectors, &java_agents, &providers)
|
||||
.map_err(IdeError::internal)?;
|
||||
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
|
||||
let policy_pins = pins.clone();
|
||||
languages.set_process_policy(Arc::new(move |plugin, cap| {
|
||||
@@ -491,6 +498,7 @@ impl PluginHost {
|
||||
ui,
|
||||
languages,
|
||||
run_detectors,
|
||||
java_agents,
|
||||
providers,
|
||||
navigation: Mutex::default(),
|
||||
endpoints: Mutex::default(),
|
||||
@@ -991,8 +999,8 @@ impl PluginHost {
|
||||
};
|
||||
// Consent covers what the install page showed.
|
||||
let request = request_for(&subject, &pkg.manifest, &hash, &set.capabilities);
|
||||
self.record_consent(&request, consent);
|
||||
let dir = install::active_dir(&root).ok_or_else(|| IdeError::internal("the installed version is missing"))?;
|
||||
self.record_consent(&request, consent, agent_jar_grant(&pkg.manifest, &dir));
|
||||
self.load_dir(&dir, PluginSource::Installed, None);
|
||||
if let Some(previous) = previous {
|
||||
let failed = self
|
||||
@@ -1110,7 +1118,7 @@ impl PluginHost {
|
||||
let hash = self.package_hash_of(&plugin);
|
||||
let extra = plugin.meta.lock().declared_extra.clone();
|
||||
let request = request_for(&plugin.subject(), plugin.manifest(), &hash, &extra);
|
||||
self.record_consent(&request, consent);
|
||||
self.record_consent(&request, consent, agent_jar_grant(plugin.manifest(), plugin.dir()));
|
||||
self.stop(&plugin);
|
||||
if !self.state.lock().disabled.contains(id) {
|
||||
self.start(&plugin);
|
||||
@@ -1160,6 +1168,12 @@ impl PluginHost {
|
||||
return Err(IdeError::invalid(format!("plugin {id:?} has not been confirmed yet")));
|
||||
}
|
||||
ledger.set(&subject, &cap, granted);
|
||||
if granted
|
||||
&& cap == Capability::JavaAgent
|
||||
&& let Some(jar) = agent_jar_grant(plugin.manifest(), plugin.dir())
|
||||
{
|
||||
ledger.set_binary(&subject, &cap, jar);
|
||||
}
|
||||
if granted
|
||||
&& let Capability::Process(program) = &cap
|
||||
&& let Some(bin) = ledger
|
||||
@@ -1696,6 +1710,11 @@ impl PluginHost {
|
||||
})
|
||||
}
|
||||
|
||||
/// Plugins' `javaAgents`, for [`ide_run::java_agent::set_java_agent_source`].
|
||||
pub fn java_agents(&self) -> Arc<dyn ide_run::java_agent::JavaAgentSource> {
|
||||
Arc::new(java_agents::PluginJavaAgents { store: self.java_agents.clone(), pins: self.pins.clone() })
|
||||
}
|
||||
|
||||
/// The syntax of plugin languages, for [`ide_language::set_external_syntax`].
|
||||
pub fn syntax_provider(self: &Arc<Self>) -> Arc<dyn ide_language::ExternalSyntax> {
|
||||
Arc::new(PluginSyntax(Arc::downgrade(self)))
|
||||
@@ -2933,7 +2952,7 @@ impl PluginHost {
|
||||
}
|
||||
let declared =
|
||||
plugin.manifest().capabilities.all().cloned().chain(plugin.meta.lock().declared_extra.clone());
|
||||
for cap in declared.filter(|c| matches!(c, Capability::Process(_))) {
|
||||
for cap in declared.filter(|c| matches!(c, Capability::Process(_) | Capability::JavaAgent)) {
|
||||
if let Some(bin) = ledger.pinned_binary(&subject, &cap) {
|
||||
pins.insert(
|
||||
(plugin.id().to_owned(), cap.to_string()),
|
||||
@@ -2994,7 +3013,9 @@ impl PluginHost {
|
||||
self.save_ledger(&ledger);
|
||||
}
|
||||
|
||||
fn record_consent(&self, request: &Request<'_>, consent: &Consent) {
|
||||
/// `agent_jar`: the jar of the plugin's `javaAgents` declaration, recorded when
|
||||
/// `java.agent` is accepted.
|
||||
fn record_consent(&self, request: &Request<'_>, consent: &Consent, agent_jar: Option<BinaryGrant>) {
|
||||
let accepted: Vec<Capability> = request.optional.iter().filter(|c| consent.accepts(c)).cloned().collect();
|
||||
let choices: BTreeMap<_, _> = {
|
||||
let ledger = self.ledger.lock();
|
||||
@@ -3016,6 +3037,7 @@ impl PluginHost {
|
||||
.get(&c.to_string())
|
||||
.map_or_else(|| self.resolve_binary(program), |path| ledger::approve_program(path).ok())
|
||||
.map(|b| (c.to_string(), b)),
|
||||
Capability::JavaAgent => agent_jar.clone().map(|jar| (c.to_string(), jar)),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
@@ -3094,6 +3116,13 @@ impl Drop for PluginHost {
|
||||
}
|
||||
}
|
||||
|
||||
/// The jar of a package's `javaAgents` declaration with its hash now, for a `java.agent` grant.
|
||||
fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
|
||||
let path = java_agents::declared_jar(manifest, dir)?;
|
||||
let hash = ledger::file_hash(&path).map_err(|e| tracing::info!("java.agent: {}: {e}", path.display())).ok()?;
|
||||
Some(BinaryGrant { path, hash })
|
||||
}
|
||||
|
||||
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
|
||||
let mut optional = m.capabilities.optional.clone();
|
||||
// What declarations need (a language server's `process:`) is optional:
|
||||
|
||||
@@ -64,6 +64,7 @@ pub fn register_builtin_points(
|
||||
ui: &Arc<UiStore>,
|
||||
languages: &Arc<PluginLanguages>,
|
||||
run_detectors: &Arc<super::run_detectors::RunDetectors>,
|
||||
java_agents: &Arc<super::java_agents::JavaAgents>,
|
||||
providers: &Arc<super::providers::Providers>,
|
||||
) -> Result<(), String> {
|
||||
registry.register(Arc::new(UiPoint::new(COMMANDS, ui.clone(), command)))?;
|
||||
@@ -71,6 +72,7 @@ pub fn register_builtin_points(
|
||||
registry.register(Arc::new(LanguagesPoint::new(languages.clone())))?;
|
||||
registry.register(Arc::new(UiPoint::new(super::icons::POINT_ID, ui.clone(), super::icons::icon_theme)))?;
|
||||
registry.register(Arc::new(super::run_detectors::RunDetectorsPoint::new(run_detectors.clone())))?;
|
||||
registry.register(Arc::new(super::java_agents::JavaAgentsPoint::new(java_agents.clone())))?;
|
||||
registry.register(Arc::new(super::navigation::IndexersPoint))?;
|
||||
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
|
||||
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
|
||||
|
||||
@@ -220,7 +220,7 @@ pub enum PluginEvent {
|
||||
ContentTabReply { plugin_id: String, request_id: String, reply: ide_plugin::ContentTabReply },
|
||||
/// Open two texts in this window's diff viewer.
|
||||
#[serde(rename_all = "camelCase")]
|
||||
OpenDiff { plugin_id: String, diff: ide_plugin::ContentDiff, file_name: Option<String> },
|
||||
OpenDiff { plugin_id: String, diff: ide_plugin::FileDiff, file_name: Option<String> },
|
||||
|
||||
/// Plugins, their status or their contributions changed: re-fetch `plugin_list`.
|
||||
CommandsChanged,
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
//! [[contributes.keymaps]]
|
||||
//! command = "check"
|
||||
//! key = "Ctrl+Alt+C" # `mac` for a different binding on macOS (`Meta+Alt+C`)
|
||||
//! # key = "Escape" + when = "…" # API 1.10: Escape in an editor that the IDE had no use for
|
||||
//!
|
||||
//! [[contributes.statusBar]]
|
||||
//! id = "branch"
|
||||
@@ -203,8 +204,16 @@ struct KeymapDecl {
|
||||
key: String,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
mac: Option<String>,
|
||||
/// Only with an `Escape` binding (API 1.10): when the command clears something.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
when: Option<String>,
|
||||
}
|
||||
|
||||
/// The one plain key a plugin may bind (API 1.10): in a focused editor, after the IDE's own uses of
|
||||
/// Escape (popups, completion, rename, selection, extra carets, Vim) found nothing to do, like a
|
||||
/// handler at the end of IDEA's EditorEscape chain.
|
||||
const ESCAPE: &str = "Escape";
|
||||
|
||||
const MODIFIERS: [&str; 4] = ["Meta", "Ctrl", "Alt", "Shift"];
|
||||
const NAMED_KEYS: [&str; 22] = [
|
||||
"Enter",
|
||||
@@ -262,9 +271,21 @@ pub fn validate_binding(binding: &str) -> Result<(), String> {
|
||||
pub(super) fn keymap(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
|
||||
let d: KeymapDecl = decode(KEYMAPS, decl)?;
|
||||
declared_command(pkg, KEYMAPS, &d.command)?;
|
||||
validate_binding(&d.key).map_err(|e| format!("contributes.keymaps: {e}"))?;
|
||||
if let Some(m) = &d.mac {
|
||||
validate_binding(m).map_err(|e| format!("contributes.keymaps: {e}"))?;
|
||||
let escape = d.key == ESCAPE || d.mac.as_deref() == Some(ESCAPE);
|
||||
if escape {
|
||||
if d.key != ESCAPE || d.mac.as_deref().is_some_and(|m| m != ESCAPE) {
|
||||
return Err("contributes.keymaps: an Escape binding is Escape on every platform".into());
|
||||
}
|
||||
pkg.manifest.needs_api("contributes.keymaps key = \"Escape\"", 10)?;
|
||||
let when = d.when.as_deref().ok_or("contributes.keymaps: an Escape binding needs a `when` clause")?;
|
||||
validate_when(when).map_err(|e| format!("contributes.keymaps: {e}"))?;
|
||||
} else if d.when.is_some() {
|
||||
return Err("contributes.keymaps: `when` is only for an Escape binding".into());
|
||||
}
|
||||
for binding in std::iter::once(&d.key).chain(&d.mac) {
|
||||
if binding != ESCAPE {
|
||||
validate_binding(binding).map_err(|e| format!("contributes.keymaps: {e}"))?;
|
||||
}
|
||||
}
|
||||
Ok(UiDecl::new(d.command.clone(), d.key.clone(), json(&d)?))
|
||||
}
|
||||
@@ -1114,6 +1135,37 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn escape_bindings_need_api_1_10_and_a_when_clause() {
|
||||
let pkg = |api: &str| {
|
||||
let manifest = ide_extension::Manifest::parse(&format!(
|
||||
"id='test'\nname='Test'\nversion='1.0.0'\nengines.openidea='{api}'\n[[contributes.commands]]\nid='clear'\ntitle='Clear'"
|
||||
))
|
||||
.unwrap();
|
||||
Package::new(manifest, std::path::PathBuf::from("/unused"))
|
||||
};
|
||||
let check = |api: &str, decl: &str| keymap(&pkg(api), toml::from_str(decl).unwrap());
|
||||
let escape = "command='clear'\nkey='Escape'\nwhen='plugin.test.active'";
|
||||
let ok = check("^1.10", escape).unwrap();
|
||||
assert_eq!(ok.json["when"], "plugin.test.active");
|
||||
assert!(check("^1.10", &format!("{escape}\nmac='Escape'")).is_ok());
|
||||
for (api, decl, error) in [
|
||||
("^1.9", escape, "1.10"),
|
||||
("^1.10", "command='clear'\nkey='Escape'", "when"),
|
||||
("^1.10", "command='clear'\nkey='Escape'\nwhen='a &&'", "when"),
|
||||
("^1.10", &format!("{escape}\nmac='Meta+K'") as &str, "every platform"),
|
||||
("^1.10", "command='clear'\nkey='Ctrl+K'\nmac='Escape'\nwhen='x'", "every platform"),
|
||||
("^1.10", "command='clear'\nkey='Ctrl+K'\nwhen='x'", "only for an Escape"),
|
||||
("^1.10", "command='clear'\nkey='Enter'", "needs Ctrl"),
|
||||
("^1.10", "command='clear'\nkey='Shift+Escape'", "needs Ctrl"),
|
||||
] {
|
||||
let err = check(api, decl).unwrap_err();
|
||||
assert!(err.contains(error), "{api} {decl}\n→ {err}");
|
||||
}
|
||||
// Other bindings are unchanged.
|
||||
assert!(check("^1.9", "command='clear'\nkey='Ctrl+Alt+C'").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bindings_need_a_modifier() {
|
||||
for ok in ["Ctrl+Alt+C", "Meta+Shift+K", "F5", "Shift+F6", "Meta+K Meta+C", "Alt+Enter"] {
|
||||
@@ -1243,7 +1295,8 @@ mod tests {
|
||||
#[test]
|
||||
fn editor_panels_validate_api_width_when_capability_and_page() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
|
||||
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
|
||||
// A Windows checkout may have CRLF line ends; the edits below match on `\n`.
|
||||
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap().replace("\r\n", "\n");
|
||||
let check = |source: &str| {
|
||||
let manifest = ide_extension::Manifest::parse(source)?;
|
||||
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
|
||||
|
||||
@@ -112,7 +112,7 @@ impl Host {
|
||||
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
|
||||
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
|
||||
let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
|
||||
let extra_roots = content_roots(&settings.effective(), &root, &build_cache);
|
||||
let extra_roots = content_roots(&settings.effective(), &root, &build_cache, trusted.load(Ordering::Acquire));
|
||||
mark("roots");
|
||||
|
||||
// The project's own registry: File Types associations may be project-scoped.
|
||||
@@ -147,7 +147,9 @@ impl Host {
|
||||
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
|
||||
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&root,
|
||||
&settings.effective().languages.java.maven.linked_projects,
|
||||
&build_cache,
|
||||
&settings.effective().languages.java.maven,
|
||||
trusted.load(Ordering::Acquire),
|
||||
));
|
||||
let settings = Arc::new(settings);
|
||||
{
|
||||
@@ -415,7 +417,10 @@ impl Host {
|
||||
// Detected excluded folders (`target`, `build`) leave the index too.
|
||||
let effective = settings.effective();
|
||||
index.set_scope(
|
||||
index_roots(&root, content_roots(&effective, &root, &build_cache)),
|
||||
index_roots(
|
||||
&root,
|
||||
content_roots(&effective, &root, &build_cache, trusted.load(Ordering::Acquire)),
|
||||
),
|
||||
exclude_globs(&root, &effective, &fresh),
|
||||
);
|
||||
*detected_roots.write() = fresh;
|
||||
@@ -458,7 +463,14 @@ impl Host {
|
||||
// through the `.git` paths above; this covers the whole tree being brought in.
|
||||
git_dirs |= batch.created.iter().any(|p| p.join(".git").exists());
|
||||
if git_dirs {
|
||||
scan_repositories(&root, &repos, &settings, &sink, &build_cache);
|
||||
scan_repositories(
|
||||
&root,
|
||||
&repos,
|
||||
&settings,
|
||||
&sink,
|
||||
&build_cache,
|
||||
trusted.load(Ordering::Acquire),
|
||||
);
|
||||
}
|
||||
let vcs_moved = batch.vcs.iter().any(|p| vcs_path_changed(p));
|
||||
if git_dirs || vcs_moved {
|
||||
@@ -544,9 +556,10 @@ impl Host {
|
||||
{
|
||||
let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());
|
||||
let build_cache = build_cache.clone();
|
||||
let trusted = trusted.load(Ordering::Acquire);
|
||||
std::thread::Builder::new()
|
||||
.name("openidea-vcs-roots".into())
|
||||
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache))?;
|
||||
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache, trusted))?;
|
||||
}
|
||||
mark("git");
|
||||
tracing::info!("opened {} in window {window} in {} ms {laps:?}", root.display(), started.elapsed().as_millis());
|
||||
@@ -907,8 +920,9 @@ fn scan_repositories(
|
||||
settings: &SettingsStore,
|
||||
sink: &SharedSink,
|
||||
build_cache: &Path,
|
||||
trusted: bool,
|
||||
) {
|
||||
match discover_repositories(root, settings, build_cache) {
|
||||
match discover_repositories(root, settings, build_cache, trusted) {
|
||||
Ok(found) => {
|
||||
if found.roots() != repos.read().roots() {
|
||||
*repos.write() = found;
|
||||
@@ -921,7 +935,7 @@ fn scan_repositories(
|
||||
|
||||
/// The repository containing `root` and those nested below it or below a content root.
|
||||
/// The project-open scan and the watcher's rescan share these skip rules.
|
||||
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path) -> IdeResult<Repos> {
|
||||
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
|
||||
let ignored = settings.effective().ignored_names();
|
||||
let skip = |p: &Path| {
|
||||
p.file_name().is_some_and(|n| {
|
||||
@@ -932,13 +946,20 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
|
||||
})
|
||||
};
|
||||
let mut roots = vec![root.to_path_buf()];
|
||||
roots.extend(content_roots(&settings.effective(), root, build_cache));
|
||||
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
|
||||
Repos::discover_roots(&roots, &skip)
|
||||
}
|
||||
|
||||
impl Project {
|
||||
pub fn refresh_repositories(&self) {
|
||||
scan_repositories(&self.root, &self.repos, &self.settings, &self.sink, &self.build_cache_dir());
|
||||
scan_repositories(
|
||||
&self.root,
|
||||
&self.repos,
|
||||
&self.settings,
|
||||
&self.sink,
|
||||
&self.build_cache_dir(),
|
||||
self.is_trusted(),
|
||||
);
|
||||
}
|
||||
|
||||
/// The project's git repositories.
|
||||
@@ -1204,7 +1225,7 @@ impl Project {
|
||||
|
||||
/// Project Structure content roots besides the project folder (existing directories).
|
||||
pub fn content_roots(&self) -> Vec<PathBuf> {
|
||||
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir())
|
||||
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir(), self.is_trusted())
|
||||
}
|
||||
|
||||
/// Applies Settings › File Types; open documents whose language changed are
|
||||
@@ -1228,7 +1249,9 @@ impl Project {
|
||||
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
|
||||
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&self.root,
|
||||
&self.settings.effective().languages.java.maven.linked_projects,
|
||||
&self.build_cache_dir(),
|
||||
&self.settings.effective().languages.java.maven,
|
||||
self.is_trusted(),
|
||||
));
|
||||
self.index.set_scope(index_roots(&self.root, roots.clone()), excludes.clone());
|
||||
self.watcher.set_excludes(&excludes);
|
||||
@@ -1354,8 +1377,14 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
|
||||
/// Workspace members in manifest order, or the attached projects outside the project and
|
||||
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
|
||||
/// extra Project Structure directories, Gradle project folders outside the project, and
|
||||
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
|
||||
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
|
||||
/// directories of Maven POMs linked from outside it and, when `trusted`, of the Maven reactor's
|
||||
/// modules there (`build_cache` holds the Gradle and Maven sync results).
|
||||
fn content_roots(
|
||||
settings: &ide_core::settings::Settings,
|
||||
root: &Path,
|
||||
build_cache: &Path,
|
||||
trusted: bool,
|
||||
) -> Vec<PathBuf> {
|
||||
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
|
||||
if workspace.is_container(root) {
|
||||
return workspace.projects;
|
||||
@@ -1365,14 +1394,14 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
|
||||
.into_iter()
|
||||
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
|
||||
.collect::<Vec<_>>();
|
||||
for path in extra_content_roots(settings, root, build_cache) {
|
||||
for path in extra_content_roots(settings, root, build_cache, trusted) {
|
||||
if !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
}
|
||||
}
|
||||
return roots;
|
||||
}
|
||||
extra_content_roots(settings, root, build_cache)
|
||||
extra_content_roots(settings, root, build_cache, trusted)
|
||||
}
|
||||
|
||||
/// The content roots plus the projects attached inside this one. The index covers those
|
||||
@@ -1439,7 +1468,7 @@ fn navigation_roots_uncached(project: &Project, from: &Path) -> Vec<PathBuf> {
|
||||
}
|
||||
}
|
||||
if workspace.is_none() {
|
||||
for root in content_roots(&settings, &project.root, &project.build_cache_dir()) {
|
||||
for root in content_roots(&settings, &project.root, &project.build_cache_dir(), project.is_trusted()) {
|
||||
if !roots.contains(&root) {
|
||||
roots.push(root);
|
||||
}
|
||||
@@ -1458,7 +1487,12 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
|
||||
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
|
||||
}
|
||||
|
||||
fn extra_content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
|
||||
fn extra_content_roots(
|
||||
settings: &ide_core::settings::Settings,
|
||||
root: &Path,
|
||||
build_cache: &Path,
|
||||
trusted: bool,
|
||||
) -> Vec<PathBuf> {
|
||||
let mut out: Vec<PathBuf> = Vec::new();
|
||||
let user = settings
|
||||
.project_structure
|
||||
@@ -1468,7 +1502,7 @@ fn extra_content_roots(settings: &ide_core::settings::Settings, root: &Path, bui
|
||||
.map(|r| PathBuf::from(r.trim()));
|
||||
for p in user
|
||||
.chain(ide_build::gradle_external_roots(root, build_cache, &settings.languages.java.gradle))
|
||||
.chain(ide_build::maven_external_roots(root, &settings.languages.java.maven.linked_projects))
|
||||
.chain(ide_build::maven_external_roots(root, build_cache, &settings.languages.java.maven, trusted))
|
||||
{
|
||||
if p.is_absolute() && p.is_dir() && !p.starts_with(root) && !out.contains(&p) {
|
||||
out.push(p);
|
||||
@@ -1954,11 +1988,11 @@ mod maven_linkage_tests {
|
||||
}
|
||||
let mut settings = ide_core::settings::Settings::default();
|
||||
settings.languages.java.maven.linked_projects = vec!["../B/pom.xml".into()];
|
||||
assert_eq!(super::content_roots(&settings, &a, &base.join("cache")), vec![b]);
|
||||
assert_eq!(super::content_roots(&settings, &a, &base.join("cache"), false), vec![b]);
|
||||
// External links must not replace jdtls's scan of the opened root with a build-file list.
|
||||
assert_eq!(super::jdtls_maven_import(&a, &settings), (Vec::new(), None));
|
||||
settings.languages.java.maven.linked_projects.clear();
|
||||
assert!(super::content_roots(&settings, &a, &base.join("cache")).is_empty());
|
||||
assert!(super::content_roots(&settings, &a, &base.join("cache"), false).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2182,7 +2216,7 @@ mod content_roots_tests {
|
||||
settings.project_structure.content_roots = vec![shared.to_string_lossy().into_owned()];
|
||||
settings.project_structure.dependencies =
|
||||
vec![dep.to_string_lossy().into_owned(), root.to_string_lossy().into_owned()];
|
||||
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
|
||||
let roots = content_roots(&settings, &root, &tmp.path().join("build"), false);
|
||||
assert_eq!(roots, vec![shared, dep]);
|
||||
}
|
||||
|
||||
@@ -2196,12 +2230,12 @@ mod content_roots_tests {
|
||||
}
|
||||
let settings = ide_core::settings::Settings::default();
|
||||
let build = ws.join("build");
|
||||
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
|
||||
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build, false)).is_empty());
|
||||
|
||||
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
|
||||
.unwrap();
|
||||
// The index walks the nested project as part of the root ...
|
||||
let roots = content_roots(&settings, &root, &build);
|
||||
let roots = content_roots(&settings, &root, &build, false);
|
||||
assert_eq!(roots, vec![other.clone()]);
|
||||
// ... while its files go to a language server of its own.
|
||||
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
|
||||
|
||||
@@ -245,10 +245,18 @@ impl crate::Host {
|
||||
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
|
||||
for project in self.projects().into_iter().filter(|p| !p.light) {
|
||||
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
|
||||
let roots = project.content_roots();
|
||||
let previous = project.trusted.swap(trusted, std::sync::atomic::Ordering::AcqRel);
|
||||
if previous == trusted {
|
||||
continue;
|
||||
}
|
||||
// Maven reactor modules outside the project are content roots of a trusted project only.
|
||||
if project.content_roots() != roots {
|
||||
project.refresh_index_scope();
|
||||
let p = project.clone();
|
||||
tokio::task::spawn_blocking(move || p.refresh_repositories());
|
||||
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
|
||||
}
|
||||
if let Some(bridge) = &project.kotlin_bridge {
|
||||
bridge.schedule();
|
||||
}
|
||||
@@ -324,6 +332,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "doc_edit"
|
||||
| "doc_folding"
|
||||
| "doc_highlights"
|
||||
| "doc_language"
|
||||
| "doc_open"
|
||||
| "doc_open_untitled"
|
||||
| "doc_open_virtual"
|
||||
@@ -338,7 +347,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "doc_set_line_ending"
|
||||
| "doc_snapshot"
|
||||
| "doc_sync_from_disk"
|
||||
| "doc_ui_mode"
|
||||
| "syntax_errors"
|
||||
| "syntax_expression_at"
|
||||
| "syntax_identifiers"
|
||||
|
||||
@@ -68,7 +68,7 @@ done
|
||||
}
|
||||
for _ in 0..20 {
|
||||
for window in ["first", "second"] {
|
||||
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
|
||||
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
|
||||
assert!(state.refreshing);
|
||||
}
|
||||
}
|
||||
@@ -87,7 +87,7 @@ done
|
||||
assert!(completed.is_ok(), "both windows must receive the completed catalog");
|
||||
for _ in 0..20 {
|
||||
for window in ["first", "second"] {
|
||||
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
|
||||
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
|
||||
assert!(!catalog.refreshing);
|
||||
assert!(catalog.retry_at_ms.is_some());
|
||||
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
|
||||
|
||||
@@ -69,3 +69,47 @@ async fn external_maven_link_persists_reloads_and_unlink_keeps_files() {
|
||||
assert_eq!(std::fs::read_to_string(sibling.join("pom.xml")).unwrap(), b_pom);
|
||||
host.shutdown().await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn reactor_module_beside_a_trusted_project_is_a_content_root_until_removed() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("aggregator");
|
||||
let service = base.join("service-a");
|
||||
std::fs::create_dir_all(root.join("core")).unwrap();
|
||||
std::fs::create_dir_all(&service).unwrap();
|
||||
let reactor = |modules: &str| {
|
||||
format!(
|
||||
"<project><artifactId>aggregator</artifactId><packaging>pom</packaging><modules>{modules}</modules></project>"
|
||||
)
|
||||
};
|
||||
std::fs::write(root.join("pom.xml"), reactor("<module>core</module><module>../service-a</module>")).unwrap();
|
||||
std::fs::write(root.join("core/pom.xml"), "<project><artifactId>core</artifactId></project>").unwrap();
|
||||
std::fs::write(service.join("pom.xml"), "<project><artifactId>service-a</artifactId></project>").unwrap();
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |window| window,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.open_project("main", &root).unwrap();
|
||||
let project = || host.project("main").unwrap();
|
||||
assert!(project().content_roots().is_empty(), "Restricted Mode does not widen the index");
|
||||
assert!(project().lsp.jdtls_import_roots().is_empty());
|
||||
|
||||
host.set_project_trust(&root, true, false).await.unwrap();
|
||||
assert_eq!(project().content_roots(), vec![service.clone()]);
|
||||
assert_eq!(project().lsp.jdtls_import_roots(), vec![service.clone()]);
|
||||
|
||||
std::fs::write(root.join("pom.xml"), reactor("<module>core</module>")).unwrap();
|
||||
project().refresh_index_scope();
|
||||
assert!(project().content_roots().is_empty());
|
||||
assert!(project().lsp.jdtls_import_roots().is_empty());
|
||||
assert!(service.join("pom.xml").is_file());
|
||||
host.shutdown().await;
|
||||
}
|
||||
@@ -481,6 +481,27 @@ async fn scope_limits_the_query_tools_to_a_directory() {
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
|
||||
let h = Harness::new();
|
||||
std::fs::create_dir_all(h.root.join("many")).unwrap();
|
||||
for i in 0..60 {
|
||||
std::fs::write(h.root.join(format!("many/m{i:02}.rs")), "pub fn pool_marker() {}\n").unwrap();
|
||||
}
|
||||
std::fs::create_dir_all(h.root.join("zz")).unwrap();
|
||||
std::fs::write(h.root.join("zz/last.rs"), "pub fn pool_marker() {}\n").unwrap();
|
||||
// Files written after the project opened reach the index through the watcher.
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
||||
while h.json("search_symbol", json!({"q":"pool_marker","limit":100})).await["items"].as_array().map_or(0, Vec::len)
|
||||
< 61
|
||||
{
|
||||
assert!(std::time::Instant::now() < deadline, "the files were never indexed");
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
}
|
||||
let found = h.json("search_symbol", json!({"q":"pool_marker","scope":"zz","limit":1})).await;
|
||||
assert_eq!(found["items"][0]["filePath"], "zz/last.rs", "{found}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
|
||||
let h = Harness::new();
|
||||
|
||||
@@ -131,9 +131,13 @@ async fn returns_all_python_classes_and_bases() {
|
||||
// Every returned entry is a Python file.
|
||||
assert!(all.iter().all(|c| { matches!(c.path.0.extension().and_then(|e| e.to_str()), Some("py" | "pyi")) }));
|
||||
|
||||
// A file changed on disk is parsed again; the others come from the cache.
|
||||
// A file changed on disk is picked up once the index re-reads it. The index is the
|
||||
// single source of truth for on-disk classes now; edits go through its update path
|
||||
// (the IDE's file watcher calls this in production).
|
||||
let extra = p.root.join("src/extra.pyi");
|
||||
std::fs::write(&extra, "class Stub(Child): ...\nclass Added(Base): ...\n").unwrap();
|
||||
p.host.project(WINDOW).unwrap().index.update(std::slice::from_ref(&extra), &[]);
|
||||
assert!(p.host.project(WINDOW).unwrap().index.wait_idle(Duration::from_secs(5)));
|
||||
let again = ops::nav::nav_inheritance(&p.host, WINDOW).await.unwrap();
|
||||
assert_eq!(find(&again, "Stub").bases, vec!["Child".to_string()]);
|
||||
assert_eq!(find(&again, "Added").bases, vec!["Base".to_string()]);
|
||||
|
||||
@@ -80,7 +80,8 @@ impl Harness {
|
||||
}
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn database_calls_enforce_grants_trust_ownership_and_uninstall_lifetime() {
|
||||
let f = Harness::new();
|
||||
// Nothing here tests the command budget, and a slow runner's first calls can exceed 250 ms.
|
||||
let f = Harness::with_timeout(Duration::from_secs(10));
|
||||
assert!(f.run("sources", None).is_err());
|
||||
f.host.set_project_trust(&f.root, true, false).await.unwrap();
|
||||
let source = f.source();
|
||||
|
||||
@@ -54,6 +54,7 @@ fn method() -> SymbolTag {
|
||||
kind: SymbolKind::Method,
|
||||
container: None,
|
||||
range: Range::new(Pos::new(0, 4), Pos::new(0, 8)),
|
||||
bases: Vec::new(),
|
||||
}
|
||||
}
|
||||
const SOURCE: &str = "def source:item\nref mapping:item\n";
|
||||
|
||||
@@ -225,6 +225,7 @@ async fn indexed_usages_rename_preview_staleness_and_grouped_undo() {
|
||||
kind: ide_core::SymbolKind::Method,
|
||||
container: None,
|
||||
range: ide_core::Range::new(Pos::new(0, 4), Pos::new(0, 5)),
|
||||
bases: Vec::new(),
|
||||
};
|
||||
plugins
|
||||
.index_navigation(
|
||||
|
||||
@@ -196,6 +196,41 @@ impl PluginWorkspace for TestWorkspace {
|
||||
self.server_messages.lock().push((method.into(), params.clone(), notify));
|
||||
Ok(if notify { serde_json::Value::Null } else { serde_json::json!({ "method": method, "params": params }) })
|
||||
}
|
||||
/// A Maven module with a lost version conflict, and a Gradle project with one report.
|
||||
fn build_graph(&self, _root: &Path) -> Result<BuildGraph, HostError> {
|
||||
let dep = |artifact: &str, version: &str| ide_build::MavenDependency {
|
||||
group_id: "org.apache.commons".into(),
|
||||
artifact_id: artifact.into(),
|
||||
version: Some(version.into()),
|
||||
scope: "compile".into(),
|
||||
..Default::default()
|
||||
};
|
||||
let mut text = dep("commons-text", "1.11.0");
|
||||
text.children = vec![ide_build::MavenDependency {
|
||||
omitted: Some(ide_build::Omission::Conflict),
|
||||
conflict_with: Some("3.14.0".into()),
|
||||
..dep("commons-lang3", "3.12.0")
|
||||
}];
|
||||
let app = ide_build::MavenProject {
|
||||
group_id: "com.example".into(),
|
||||
artifact_id: "app".into(),
|
||||
version: "1.0".into(),
|
||||
dependencies: vec![text],
|
||||
..Default::default()
|
||||
};
|
||||
let snakeyaml = ide_build::GradleDependency {
|
||||
group: "org.yaml".into(),
|
||||
name: "snakeyaml".into(),
|
||||
requested: Some("2.2".into()),
|
||||
..Default::default()
|
||||
};
|
||||
let report = ide_build::GradleReport {
|
||||
project: ":web".into(),
|
||||
configuration: "runtimeClasspath".into(),
|
||||
dependencies: vec![snakeyaml],
|
||||
};
|
||||
Ok(BuildGraph { maven: vec![app], gradle: vec![GradleModule { path: ":web".into(), reports: vec![report] }] })
|
||||
}
|
||||
fn project_windows(&self, root: &Path) -> Vec<String> {
|
||||
// `main` shows the fixture project; other open roots have no window left.
|
||||
if root == self.root { vec!["closing".into(), "main".into()] } else { Vec::new() }
|
||||
@@ -2151,6 +2186,60 @@ fn run_detectors_offer_granted_commands_in_marked_projects() {
|
||||
assert!(detection.launch(config).unwrap_err().contains("no longer enabled"));
|
||||
}
|
||||
|
||||
/// A plugin's Java agent (`[[contributes.javaAgents]]`, the `java-agent` fixture): an optional
|
||||
/// high-risk `java.agent` capability; refusing or revoking it keeps the plugin working and the
|
||||
/// launch gets no agent; granting it pins the jar, which may not change afterwards.
|
||||
#[test]
|
||||
fn java_agent_loads_only_while_granted_and_unchanged() {
|
||||
let f = fixture(Limits::default());
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let pkg = tmp.path().join("java-agent");
|
||||
copy_dir(&sample("java-agent"), &pkg);
|
||||
let preview = f.host.preview_install(&pkg).unwrap();
|
||||
let cap = preview.capabilities.iter().find(|c| c.id == "java.agent").expect("derived from the declaration");
|
||||
assert!(cap.optional && cap.risk == ide_extension::Risk::High && !cap.granted);
|
||||
assert_eq!(cap.description, "Run code inside the Java applications you start");
|
||||
|
||||
// Refused on install: the plugin is on, Java launches get no agent.
|
||||
let info = f.host.install_from_dir(&pkg, &Consent::default()).unwrap();
|
||||
assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
|
||||
assert!(info.contributions.iter().any(|c| c.point == "javaAgents" && c.label == "fixture agent.jar=mode=test"));
|
||||
let source = f.host.java_agents();
|
||||
let launch = || {
|
||||
let agents = ide_run::java_agent::approved(&source.agents());
|
||||
let mut args: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
|
||||
ide_run::java_agent::add_to_args(&mut args, &agents.options);
|
||||
(args, agents.notes)
|
||||
};
|
||||
let plain: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
|
||||
assert_eq!(launch(), (plain.clone(), vec![]));
|
||||
|
||||
// Granted: the installed jar with its arguments, one argument after the VM options.
|
||||
let info = f.host.set_capability("java-agent", "java.agent", true).unwrap();
|
||||
assert!(info.capabilities.iter().any(|c| c.id == "java.agent" && c.granted));
|
||||
let jar = dunce::canonicalize(f.installed("java-agent").join("agent/fixture agent.jar")).unwrap();
|
||||
let option = format!("-javaagent:{}=mode=test", jar.display());
|
||||
let mut with_agent = plain.clone();
|
||||
with_agent.insert(3, option.clone());
|
||||
assert_eq!(launch(), (with_agent.clone(), vec![]));
|
||||
|
||||
// The jar changed since it was granted: left out, with a reason, until approved again.
|
||||
std::fs::write(&jar, "swapped").unwrap();
|
||||
let (args, notes) = launch();
|
||||
assert_eq!(args, plain);
|
||||
assert!(notes.len() == 1 && notes[0].contains("changed since it was approved"), "{notes:?}");
|
||||
f.host.set_capability("java-agent", "java.agent", true).unwrap();
|
||||
assert_eq!(launch(), (with_agent.clone(), vec![]));
|
||||
|
||||
// Revoked, then the plugin disabled: no agent either way.
|
||||
f.host.set_capability("java-agent", "java.agent", false).unwrap();
|
||||
assert_eq!(f.status("java-agent"), PluginStatus::Static);
|
||||
assert_eq!(launch(), (plain.clone(), vec![]));
|
||||
f.host.set_capability("java-agent", "java.agent", true).unwrap();
|
||||
f.host.set_enabled("java-agent", false).unwrap();
|
||||
assert_eq!(launch(), (plain, vec![]));
|
||||
}
|
||||
|
||||
/// Compiled components are cached across runs (keyed by module and
|
||||
/// engine), so a cold activation only deserializes.
|
||||
#[test]
|
||||
@@ -6518,8 +6607,8 @@ fn a_plugin_command_opens_a_diff_in_its_window() {
|
||||
client.as_deref() == Some("main")
|
||||
&& matches!(event, PluginEvent::OpenDiff { plugin_id, diff, file_name }
|
||||
if plugin_id == "execution"
|
||||
&& diff.left == "before\n"
|
||||
&& diff.right == "after\n"
|
||||
&& diff.left.as_deref() == Some("before\n")
|
||||
&& diff.right.as_deref() == Some("after\n")
|
||||
&& diff.title.as_deref() == Some("Review")
|
||||
&& file_name.as_deref() == Some("src/review.rs"))
|
||||
})
|
||||
@@ -7022,6 +7111,59 @@ fn the_language_server_grant_needs_api_1_9() {
|
||||
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
|
||||
}
|
||||
|
||||
/// `build.dependencies` hands a plugin the resolved Maven / Gradle graph as a flat list, each
|
||||
/// module a root, with `build.read` in a trusted project (API 1.10).
|
||||
#[test]
|
||||
fn build_dependencies_need_the_grant_and_a_trusted_project() {
|
||||
let f = fixture(Limits::default());
|
||||
let id = "test.build-graph";
|
||||
let info = f.install(&sample("build-graph"));
|
||||
assert!(info.capabilities.iter().any(|c| c.id == "build.read" && c.granted && c.risk == ide_extension::Risk::Low));
|
||||
|
||||
// `parent group:artifact:version scope status requested`, as the fixture prints them.
|
||||
assert_eq!(
|
||||
f.run(id, "dependencies", None).unwrap().unwrap(),
|
||||
"- com.example:app:1.0 resolved -\n\
|
||||
0 org.apache.commons:commons-text:1.11.0 compile resolved -\n\
|
||||
1 org.apache.commons:commons-lang3:3.14.0 compile conflict 3.12.0\n\
|
||||
- ::web: resolved -\n\
|
||||
3 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
|
||||
);
|
||||
assert_eq!(
|
||||
f.run(id, "dependencies", Some(":web")).unwrap().unwrap(),
|
||||
"- ::web: resolved -\n0 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
|
||||
);
|
||||
let err = f.host.run_command(id, "dependencies", Some("app"), f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::NotFound, "{err:?}");
|
||||
|
||||
f.host.set_capability(id, "build.read", false).unwrap();
|
||||
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
|
||||
assert!(err.message.contains("build.read"), "{err:?}");
|
||||
f.host.set_capability(id, "build.read", true).unwrap();
|
||||
|
||||
// The graph comes from running the project's build: not in an untrusted project.
|
||||
let mut untrusted = TestWorkspace::new(&f.project);
|
||||
Arc::get_mut(&mut untrusted).unwrap().trusted = false;
|
||||
f.host.set_workspace(Some(untrusted));
|
||||
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
|
||||
assert_eq!(f.host.info_of(id).unwrap().stats.crashes, 0);
|
||||
}
|
||||
|
||||
/// The grant is new in API 1.10: an older `engines.openidea` can't ask for it.
|
||||
#[test]
|
||||
fn the_build_grant_needs_api_1_10() {
|
||||
let f = fixture(Limits::default());
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let pkg = tmp.path().join("build-graph");
|
||||
copy_dir(&sample("build-graph"), &pkg);
|
||||
let manifest = std::fs::read_to_string(pkg.join("plugin.toml")).unwrap();
|
||||
std::fs::write(pkg.join("plugin.toml"), manifest.replace("\"^1.10\"", "\"^1.9\"")).unwrap();
|
||||
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("new in plugin API 1.10"), "{err:?}");
|
||||
}
|
||||
|
||||
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
|
||||
/// subscribes to `on-event:settings-changed`, though it carries no keys.
|
||||
#[test]
|
||||
|
||||
@@ -106,6 +106,9 @@ pub(crate) struct StoredSymbol {
|
||||
pub kind: SymbolKind,
|
||||
pub container: Option<String>,
|
||||
pub range: Range,
|
||||
/// Base names of a class definition; empty for every other symbol.
|
||||
#[serde(default)]
|
||||
pub bases: Vec<String>,
|
||||
}
|
||||
|
||||
/// A symbol resolved out of [`SymTable`].
|
||||
@@ -114,6 +117,8 @@ pub(crate) struct SymRef<'a> {
|
||||
pub kind: SymbolKind,
|
||||
pub container: Option<&'a str>,
|
||||
pub range: Range,
|
||||
/// Base names joined with `'\0'`; empty when the symbol has none.
|
||||
pub bases: &'a str,
|
||||
}
|
||||
|
||||
pub(crate) struct FileEntry {
|
||||
@@ -402,6 +407,8 @@ pub(crate) struct SymTable {
|
||||
container: Vec<Span>,
|
||||
kind: Vec<SymbolKind>,
|
||||
range: Vec<Range>,
|
||||
/// Base names joined with `'\0'`, one interned span per symbol (`NONE` for none).
|
||||
bases: Vec<Span>,
|
||||
text: String,
|
||||
dead_rows: usize,
|
||||
}
|
||||
@@ -423,6 +430,18 @@ impl SymTable {
|
||||
(span.start != u32::MAX).then(|| span.get(&self.text))
|
||||
}
|
||||
|
||||
/// The symbol's base names joined with `'\0'`; empty when it has none.
|
||||
#[inline]
|
||||
pub(crate) fn bases(&self, i: u32) -> &str {
|
||||
let span = self.bases[i as usize];
|
||||
if span.start == u32::MAX { "" } else { span.get(&self.text) }
|
||||
}
|
||||
|
||||
/// The base names of row `i`, split out of the interned string.
|
||||
pub(crate) fn base_list(&self, i: u32) -> Vec<&str> {
|
||||
self.bases(i).split('\0').filter(|b| !b.is_empty()).collect()
|
||||
}
|
||||
|
||||
/// The mask + name rows of a file's contiguous symbol range.
|
||||
#[inline]
|
||||
pub(crate) fn heads(&self, start: u32, len: u32) -> &[SymHead] {
|
||||
@@ -459,10 +478,12 @@ impl SymTable {
|
||||
Some(c) => self.intern(c),
|
||||
None => Span::NONE,
|
||||
};
|
||||
let bases = if s.bases.is_empty() { Span::NONE } else { self.intern(&s.bases.join("\0")) };
|
||||
self.head.push(SymHead { mask, name });
|
||||
self.container.push(container);
|
||||
self.kind.push(s.kind);
|
||||
self.range.push(s.range);
|
||||
self.bases.push(bases);
|
||||
}
|
||||
(start, agg_mask)
|
||||
}
|
||||
@@ -476,6 +497,7 @@ impl SymTable {
|
||||
&& self.container(i) == s.container.as_deref()
|
||||
&& self.kind(i) == s.kind
|
||||
&& self.range(i) == s.range
|
||||
&& self.base_list(i) == s.bases.iter().map(String::as_str).collect::<Vec<_>>()
|
||||
})
|
||||
}
|
||||
|
||||
@@ -492,6 +514,7 @@ impl SymTable {
|
||||
let mut container = Vec::with_capacity(head.capacity());
|
||||
let mut kind = Vec::with_capacity(head.capacity());
|
||||
let mut range = Vec::with_capacity(head.capacity());
|
||||
let mut bases = Vec::with_capacity(head.capacity());
|
||||
let mut live = 0u32;
|
||||
for (slot, row) in rows.iter_mut().enumerate() {
|
||||
if !row.live {
|
||||
@@ -518,6 +541,14 @@ impl SymTable {
|
||||
}
|
||||
kind.push(self.kind[i as usize]);
|
||||
range.push(self.range[i as usize]);
|
||||
let bases_span = self.bases[i as usize];
|
||||
if bases_span.start == u32::MAX {
|
||||
bases.push(Span::NONE);
|
||||
} else {
|
||||
let b = bases_span.get(&self.text);
|
||||
bases.push(Span::of(&text, b));
|
||||
text.push_str(b);
|
||||
}
|
||||
live += 1;
|
||||
}
|
||||
}
|
||||
@@ -525,6 +556,7 @@ impl SymTable {
|
||||
self.container = container;
|
||||
self.kind = kind;
|
||||
self.range = range;
|
||||
self.bases = bases;
|
||||
self.text = text;
|
||||
self.dead_rows = 0;
|
||||
}
|
||||
@@ -534,6 +566,7 @@ impl SymTable {
|
||||
self.container.shrink_to_fit();
|
||||
self.kind.shrink_to_fit();
|
||||
self.range.shrink_to_fit();
|
||||
self.bases.shrink_to_fit();
|
||||
self.text.shrink_to_fit();
|
||||
}
|
||||
}
|
||||
@@ -577,6 +610,7 @@ impl IndexData {
|
||||
self.syms.container.reserve(symbols);
|
||||
self.syms.kind.reserve(symbols);
|
||||
self.syms.range.reserve(symbols);
|
||||
self.syms.bases.reserve(symbols);
|
||||
}
|
||||
|
||||
/// Hydrates a validated warm-start snapshot in one pass, without per-file
|
||||
@@ -640,6 +674,7 @@ impl IndexData {
|
||||
kind: s.kind,
|
||||
container: s.container.map(str::to_owned),
|
||||
range: s.range,
|
||||
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
|
||||
})
|
||||
.collect(),
|
||||
ignored: e.ignored,
|
||||
@@ -666,6 +701,7 @@ impl IndexData {
|
||||
kind: syms.kind(i),
|
||||
container: syms.container(i),
|
||||
range: syms.range(i),
|
||||
bases: syms.bases(i),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -823,6 +859,7 @@ mod tests {
|
||||
kind: SymbolKind::Function,
|
||||
container: None,
|
||||
range: Range::default(),
|
||||
bases: Vec::new(),
|
||||
})
|
||||
.collect(),
|
||||
..Default::default()
|
||||
@@ -957,7 +994,13 @@ mod tests {
|
||||
}
|
||||
|
||||
fn symbol(n: &str) -> StoredSymbol {
|
||||
StoredSymbol { name: n.to_owned(), kind: SymbolKind::Function, container: None, range: Range::default() }
|
||||
StoredSymbol {
|
||||
name: n.to_owned(),
|
||||
kind: SymbolKind::Function,
|
||||
container: None,
|
||||
range: Range::default(),
|
||||
bases: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -50,6 +50,17 @@ pub struct SymbolMatch {
|
||||
pub indices: MatchIndices,
|
||||
}
|
||||
|
||||
/// A class declaration of the index and the base names written in its source.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ClassDecl {
|
||||
pub path: PathBuf,
|
||||
pub name: String,
|
||||
/// Selection range: the class name's identifier.
|
||||
pub range: Range,
|
||||
/// Bare base names, as written (`class X(pkg.mod.Base)` keeps `Base`).
|
||||
pub bases: Vec<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum SymbolFilter {
|
||||
@@ -206,11 +217,34 @@ impl ProjectIndex {
|
||||
kind: s.kind,
|
||||
container: s.container.map(ToString::to_string),
|
||||
range: s.range,
|
||||
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Every class declaration of the indexed project (content roots included) with the
|
||||
/// base names written in its source, in path order. The UI builds an inheritance
|
||||
/// graph from it, so it needs no language server's type hierarchy.
|
||||
pub fn inheritance(&self) -> Vec<ClassDecl> {
|
||||
let data = self.shared.data.read();
|
||||
let mut out = Vec::new();
|
||||
for entry in data.files.iter().flatten() {
|
||||
for s in data.symbols_of(entry) {
|
||||
if s.kind != SymbolKind::Class {
|
||||
continue;
|
||||
}
|
||||
out.push(ClassDecl {
|
||||
path: entry.path.clone(),
|
||||
name: s.name.to_owned(),
|
||||
range: s.range,
|
||||
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
|
||||
});
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Bounded file inventory for background plugin indexers; honors the same
|
||||
/// project/exclude scope as search and never walks the filesystem.
|
||||
pub fn files_with_extensions(&self, extensions: &[String], limit: usize) -> Vec<PathBuf> {
|
||||
@@ -517,6 +551,7 @@ pub mod bench_support {
|
||||
kind: if k % 3 == 0 { SymbolKind::Class } else { SymbolKind::Method },
|
||||
container: (k % 3 != 0).then(|| format!("{w}{s}")),
|
||||
range: Range::default(),
|
||||
bases: Vec::new(),
|
||||
})
|
||||
.collect();
|
||||
let record = FileRecord { symbols, ..Default::default() };
|
||||
|
||||
@@ -11,8 +11,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
|
||||
|
||||
const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
|
||||
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
|
||||
/// Bump when [`FileRecord`] or its encoding changes.
|
||||
const SCHEMA: &str = "openidea-index-3";
|
||||
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
|
||||
const SCHEMA: &str = "openidea-index-4";
|
||||
|
||||
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
|
||||
/// containing `gitdir: ...`).
|
||||
@@ -113,6 +113,9 @@ struct FlatSymbol {
|
||||
name_len: u32,
|
||||
container_start: u32,
|
||||
container_len: u32,
|
||||
/// Base names joined with `'\0'` (`bases_len` 0 when the symbol has none).
|
||||
bases_start: u32,
|
||||
bases_len: u32,
|
||||
kind: SymbolKind,
|
||||
range: Range,
|
||||
}
|
||||
@@ -324,11 +327,14 @@ impl Snapshot {
|
||||
let start = s.container_start as usize;
|
||||
&self.text[start..start + s.container_len as usize]
|
||||
});
|
||||
let bases_start = s.bases_start as usize;
|
||||
let bases = &self.text[bases_start..bases_start + s.bases_len as usize];
|
||||
StoredSymbol {
|
||||
name: name.to_owned(),
|
||||
kind: s.kind,
|
||||
container: container.map(str::to_owned),
|
||||
range: s.range,
|
||||
bases: bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
@@ -498,11 +504,15 @@ impl Store {
|
||||
}
|
||||
None => (u32::MAX, 0),
|
||||
};
|
||||
let bases_start = fit(snap.text.len())?;
|
||||
snap.text.push_str(s.bases);
|
||||
snap.symbols.push(FlatSymbol {
|
||||
name_start,
|
||||
name_len: fit(s.name.len())?,
|
||||
container_start,
|
||||
container_len,
|
||||
bases_start,
|
||||
bases_len: fit(s.bases.len())?,
|
||||
kind: s.kind,
|
||||
range: s.range,
|
||||
});
|
||||
@@ -717,6 +727,7 @@ mod tests {
|
||||
kind: SymbolKind::Class,
|
||||
container: Some("Order".into()),
|
||||
range: Range::default(),
|
||||
bases: vec!["Base".into()],
|
||||
}],
|
||||
..Default::default()
|
||||
};
|
||||
@@ -740,6 +751,7 @@ mod tests {
|
||||
assert_eq!(symbols.len(), 1);
|
||||
assert_eq!(symbols[0].name, "OrderController");
|
||||
assert_eq!(symbols[0].container.as_deref(), Some("Order"));
|
||||
assert_eq!(symbols[0].bases, vec!["Base".to_string()], "bases survive the snapshot");
|
||||
|
||||
store.apply(&[], &[], false).unwrap();
|
||||
assert!(store.load_snapshot().is_none(), "a file change invalidates the snapshot");
|
||||
|
||||
@@ -567,6 +567,29 @@ fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
|
||||
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inheritance_reports_python_classes_and_their_bases() {
|
||||
let f = Fixture::new(&[(
|
||||
"app.py",
|
||||
"class Base:\n pass\n\nclass Child(Base, other.Mixin):\n pass\n\nclass Plain:\n pass\n",
|
||||
)]);
|
||||
let idx = f.open();
|
||||
let mut found: Vec<(String, u32, Vec<String>)> =
|
||||
idx.inheritance().into_iter().map(|c| (c.name, c.range.start.line, c.bases)).collect();
|
||||
found.sort();
|
||||
assert_eq!(
|
||||
found,
|
||||
vec![
|
||||
("Base".to_string(), 0, Vec::new()),
|
||||
("Child".to_string(), 3, vec!["Base".to_string(), "Mixin".to_string()]),
|
||||
("Plain".to_string(), 6, Vec::new()),
|
||||
]
|
||||
);
|
||||
// Every class of the project is reported, even without a superclass: the UI needs
|
||||
// them to resolve the base names of other files.
|
||||
assert_eq!(idx.inheritance().len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn content_roots_and_excludes_change_without_reopening() {
|
||||
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
|
||||
|
||||
@@ -752,7 +752,13 @@ impl Shared {
|
||||
.syntax
|
||||
.tags(&lang, &text)
|
||||
.into_iter()
|
||||
.map(|t| StoredSymbol { name: t.name, kind: t.kind, container: t.container, range: t.range })
|
||||
.map(|t| StoredSymbol {
|
||||
name: t.name,
|
||||
kind: t.kind,
|
||||
container: t.container,
|
||||
range: t.range,
|
||||
bases: t.bases,
|
||||
})
|
||||
.collect();
|
||||
}
|
||||
Extracted::New(rec)
|
||||
|
||||
@@ -8,8 +8,6 @@ license.workspace = true
|
||||
[dependencies]
|
||||
futures.workspace = true
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
specta.workspace = true
|
||||
thiserror.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
serde_json.workspace = true
|
||||
@@ -2,8 +2,10 @@
|
||||
//! suspended. Implementations live elsewhere (jdtls bundle for Java, JDWP link for Kotlin).
|
||||
|
||||
mod names;
|
||||
mod stream;
|
||||
|
||||
pub use names::{is_boxed, name_to_signature, signature_to_name, string_length};
|
||||
pub use stream::{AbortState, CollectedTerminal, StreamTracer, TraceCollected, TraceId, TraceState};
|
||||
|
||||
use futures::future::BoxFuture;
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -112,6 +114,15 @@ pub enum InspectError {
|
||||
VmNotFound,
|
||||
#[error("not supported by this debug adapter: {0}")]
|
||||
Unsupported(String),
|
||||
#[error("java-debug has no debug session for this JVM")]
|
||||
NoSession,
|
||||
/// The bundle's reason, e.g. which line the chain starts on.
|
||||
#[error("the debuggee is not stopped where the stream chain starts: {0}")]
|
||||
NotAtChainStart(String),
|
||||
#[error("a stream trace is already running in this JVM")]
|
||||
Busy,
|
||||
#[error("there is no such stream trace in this JVM")]
|
||||
NoTrace,
|
||||
#[error("the request timed out")]
|
||||
TimedOut,
|
||||
#[error("the connection was closed")]
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
//! Tracing a stream chain while the program itself runs it. One trace per VM; the trace's records
|
||||
//! are read back once the debuggee is suspended again.
|
||||
|
||||
use crate::{InspectFuture, JvmValue, VmTarget};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
/// Assigned by the debuggee-side bundle; valid for one VM.
|
||||
pub type TraceId = u64;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum TraceState {
|
||||
Running {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
elapsed_ms: u64,
|
||||
},
|
||||
/// The terminal operation finished and the thread is suspended again, ready to `collect`.
|
||||
Parked {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
},
|
||||
Failed {
|
||||
detail: String,
|
||||
},
|
||||
/// Stopped or aborted before the terminal operation ran: taken down, the program untouched.
|
||||
Cancelled {
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
pub enum AbortState {
|
||||
Interrupted,
|
||||
Stopped,
|
||||
/// Suspended threads that own a monitor the terminal may be waiting for: `(thread id, name)`.
|
||||
Stuck {
|
||||
holders: Vec<(i64, String)>,
|
||||
},
|
||||
/// The terminal had not started.
|
||||
Cancelled,
|
||||
/// The trace had already parked or failed.
|
||||
Finished,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum CollectedTerminal {
|
||||
Value(JvmValue),
|
||||
Void,
|
||||
Threw(JvmValue),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct TraceCollected {
|
||||
/// `(step, value)`: step counts the wrapped ops from 0 (the source).
|
||||
pub records: Vec<(u16, JvmValue)>,
|
||||
/// Records past the arm-time budget; counted, not kept.
|
||||
pub dropped: u64,
|
||||
pub terminal: CollectedTerminal,
|
||||
pub skipped_breakpoints: u32,
|
||||
/// A parallel chain was forced to run sequentially so that records keep their order.
|
||||
pub sequentialized: bool,
|
||||
}
|
||||
|
||||
pub trait StreamTracer: Send + Sync {
|
||||
/// `plan` is the JSON of `ide_streams::RealRunPlan`; `budget` caps the records kept. `token`
|
||||
/// names the trace for [`release_armed`](Self::release_armed) when no reply arrives.
|
||||
fn arm<'a>(
|
||||
&'a self,
|
||||
target: &'a VmTarget,
|
||||
thread_id: i64,
|
||||
plan: &'a serde_json::Value,
|
||||
budget: u32,
|
||||
token: &'a str,
|
||||
) -> InspectFuture<'a, TraceId>;
|
||||
/// Blocks up to `ms` milliseconds for the trace to leave `Running`.
|
||||
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState>;
|
||||
/// Stops keeping records while the terminal keeps running; returns the records kept so far.
|
||||
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64>;
|
||||
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState>;
|
||||
/// `target.generation` must be a stop after the trace parked. `records`: how many it parked
|
||||
/// with; reading each takes a round trip to the JVM, so the time allowed grows with them.
|
||||
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected>;
|
||||
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()>;
|
||||
/// Releases the trace armed with `token` whose `arm` reply never came (it timed out); nothing
|
||||
/// when there is none.
|
||||
fn release_armed<'a>(&'a self, target: &'a VmTarget, token: &'a str) -> InspectFuture<'a, ()>;
|
||||
}
|
||||
@@ -73,6 +73,21 @@ pub struct LanguageConfig {
|
||||
/// Content of a new scratch file; `$END$` marks where the caret goes.
|
||||
#[serde(default)]
|
||||
pub scratch_template: Option<String>,
|
||||
/// Syntax nodes of the editor's grammar whose `<` `>` rainbow brackets colour.
|
||||
#[serde(default)]
|
||||
pub rainbow_brackets: RainbowBracketNodes,
|
||||
}
|
||||
|
||||
/// `[rainbow-brackets]` of a language definition: node names of its editor (Lezer)
|
||||
/// grammar, so angle brackets are coloured only where the syntax tree says they
|
||||
/// delimit something, never in comparisons or shifts.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(default)]
|
||||
pub struct RainbowBracketNodes {
|
||||
/// Nodes spanning `<` … `>` whose delimiters pair up: type argument and parameter lists.
|
||||
pub angle: Vec<String>,
|
||||
/// Markup tags (`<a>`, `</a>`, `<a/>`); an element's start and end tags pair up.
|
||||
pub tags: Vec<String>,
|
||||
}
|
||||
|
||||
/// An external formatting tool and its language-specific parser.
|
||||
@@ -302,6 +317,10 @@ pub struct LanguageInfo {
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub scratch_template: Option<String>,
|
||||
/// Syntax nodes whose `<` `>` rainbow brackets colour (Color Scheme › Rainbow brackets).
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub rainbow_brackets: RainbowBracketNodes,
|
||||
}
|
||||
|
||||
impl From<&LanguageConfig> for LanguageInfo {
|
||||
@@ -319,6 +338,7 @@ impl From<&LanguageConfig> for LanguageInfo {
|
||||
filenames: c.filenames.clone(),
|
||||
first_line: c.first_line.clone(),
|
||||
scratch_template: c.scratch_template.clone(),
|
||||
rainbow_brackets: c.rainbow_brackets.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -347,6 +367,10 @@ pub struct SymbolTag {
|
||||
/// Enclosing symbol, e.g. class name for a method.
|
||||
pub container: Option<String>,
|
||||
pub range: Range,
|
||||
/// Bare base names written in a class definition (`class X(A, B)`); empty for
|
||||
/// every other symbol, and for languages whose classes carry none.
|
||||
#[serde(default)]
|
||||
pub bases: Vec<String>,
|
||||
}
|
||||
|
||||
/// One inline TS/JS `<script>` block of a Vue SFC / HTML document.
|
||||
|
||||
@@ -667,6 +667,20 @@ mod tests {
|
||||
assert_eq!(rust.language_servers[0].name, "rust-analyzer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rainbow_bracket_nodes_reach_the_ui() {
|
||||
let reg = reg();
|
||||
let tsx = reg.get(&LanguageId::new("typescriptreact")).unwrap();
|
||||
assert_eq!(tsx.rainbow_brackets.angle, ["TypeArgList", "TypeParamList"]);
|
||||
assert!(tsx.rainbow_brackets.tags.iter().any(|t| t == "JSXOpenTag"));
|
||||
let info = crate::LanguageInfo::from(®.get(&LanguageId::new("html")).unwrap());
|
||||
assert_eq!(info.rainbow_brackets.tags, ["OpenTag", "CloseTag", "SelfClosingTag"]);
|
||||
let json = serde_json::to_value(&info).unwrap();
|
||||
assert_eq!(json["rainbowBrackets"]["tags"][0], "OpenTag");
|
||||
// Definitions without the table, as most are, get none.
|
||||
assert_eq!(reg.get(&LanguageId::new("python")).unwrap().rainbow_brackets, Default::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alternative_servers_are_fallbacks() {
|
||||
let reg = reg();
|
||||
|
||||
@@ -67,9 +67,10 @@ fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The bare base names a `class_definition` node writes (keyword arguments left out).
|
||||
pub(super) fn class_base_names(node: Node, text: &str) -> Vec<String> {
|
||||
node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
|
||||
/// Bare base names of a `class_definition` node (`[]` without a superclass list).
|
||||
/// Shared with the outline query, whose tags carry the bases of a class definition.
|
||||
pub(super) fn class_base_names(class: Node, text: &str) -> Vec<String> {
|
||||
class.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn base_names(args: Node, text: &str) -> Vec<String> {
|
||||
@@ -121,6 +122,20 @@ mod tests {
|
||||
assert_eq!(shape("class A: pass"), vec![("A".to_owned(), 0, 6, vec![])]);
|
||||
}
|
||||
|
||||
/// The project index stores bases on the symbol tags, so the outline query must
|
||||
/// carry them too (one parse for both, not a second pass over every file).
|
||||
#[test]
|
||||
fn tags_carry_class_bases() {
|
||||
static S: std::sync::OnceLock<Syntax> = std::sync::OnceLock::new();
|
||||
let s = S.get_or_init(Syntax::new);
|
||||
let tags = s.tags(&LanguageId::new("python"), "class A: pass\nclass B(A, pkg.C):\n def m(self): pass\n");
|
||||
let bases_of = |name: &str| tags.iter().find(|t| t.name == name).map(|t| t.bases.clone()).unwrap_or_default();
|
||||
assert!(bases_of("A").is_empty());
|
||||
assert_eq!(bases_of("B"), vec!["A".to_owned(), "C".to_owned()]);
|
||||
// Only classes carry bases; the method's tag stays empty.
|
||||
assert!(bases_of("m").is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multiple_bases_skips_metaclass() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -73,6 +73,33 @@ pub struct SpellingRegion {
|
||||
pub start: usize,
|
||||
pub end: usize,
|
||||
pub kind: SpellingKind,
|
||||
/// A raw / verbatim string: backslashes are literal text, not escapes
|
||||
/// (`r"\user"`, `r#"…"#`, `` `…` ``, `@"…"`). The spelling layer must not
|
||||
/// skip the character after a `\` in one of these.
|
||||
pub raw: bool,
|
||||
}
|
||||
|
||||
/// Whether `node` is a string literal whose backslashes are not escapes.
|
||||
fn is_raw_string(node: &Node<'_>, text: &str) -> bool {
|
||||
let kind = node.kind();
|
||||
// Rust/C++/C# grammars name the node directly.
|
||||
if kind == "raw_string_literal" || kind == "verbatim_string_literal" || kind.contains("raw_string") {
|
||||
return true;
|
||||
}
|
||||
// Go backtick strings and Python `r`/`fr`/`rb` prefixes: the grammar uses
|
||||
// the generic `string` node, so inspect the literal's own prefix.
|
||||
if kind == "string" || kind == "string_literal" {
|
||||
let literal = &text[node.start_byte()..node.end_byte()];
|
||||
if literal.starts_with('`') {
|
||||
return true;
|
||||
}
|
||||
let quote = literal.find(['"', '\'']);
|
||||
let prefix = quote.map_or("", |i| &literal[..i]);
|
||||
return !prefix.is_empty()
|
||||
&& prefix.chars().any(|c| c == 'r' || c == 'R')
|
||||
&& prefix.chars().all(|c| matches!(c, 'r' | 'R' | 'b' | 'B' | 'f' | 'F' | 'u' | 'U'));
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn is_name_leaf(kind: &str) -> bool {
|
||||
@@ -101,16 +128,20 @@ fn declares(cursor: &TreeCursor<'_>, node: &Node<'_>) -> bool {
|
||||
}
|
||||
|
||||
/// Comments, string literals and declared names, for spell checking.
|
||||
pub(crate) fn spelling_regions(tree: &Tree) -> Vec<SpellingRegion> {
|
||||
pub(crate) fn spelling_regions(tree: &Tree, text: &str) -> Vec<SpellingRegion> {
|
||||
let mut out = Vec::new();
|
||||
let mut cursor = tree.walk();
|
||||
loop {
|
||||
let node = cursor.node();
|
||||
let literal = kind_of(&node);
|
||||
let region = |kind| SpellingRegion { start: node.start_byte(), end: node.end_byte(), kind };
|
||||
let region = |kind| SpellingRegion { start: node.start_byte(), end: node.end_byte(), kind, raw: false };
|
||||
match literal {
|
||||
Some(LiteralKind::Comment) => out.push(region(SpellingKind::Comment)),
|
||||
Some(LiteralKind::String) => out.push(region(SpellingKind::String)),
|
||||
Some(LiteralKind::String) => {
|
||||
let mut r = region(SpellingKind::String);
|
||||
r.raw = is_raw_string(&node, text);
|
||||
out.push(r);
|
||||
}
|
||||
None if node.is_named()
|
||||
&& node.child_count() == 0
|
||||
&& is_name_leaf(node.kind())
|
||||
|
||||
@@ -294,7 +294,7 @@ impl Syntax {
|
||||
/// Comments, string literals and declared names (byte ranges, document
|
||||
/// order) for the Typo inspection; `None` like [`Self::literals`].
|
||||
pub fn spelling_regions(&self, lang: &LanguageId, text: &str) -> Option<Vec<SpellingRegion>> {
|
||||
self.analyze(lang, text, |_, tree, _| Some(literals::spelling_regions(tree)))
|
||||
self.analyze(lang, text, |_, tree, text| Some(literals::spelling_regions(tree, text)))
|
||||
}
|
||||
|
||||
/// Syntax-aware selection ranges for IDEA "Extend Selection" (⌥↑), innermost first.
|
||||
|
||||
@@ -143,6 +143,8 @@ struct Raw {
|
||||
visibility: Option<Visibility>,
|
||||
/// Rust `impl Trait for Type`: members take the trait's visibility.
|
||||
trait_impl: bool,
|
||||
/// Base names of a class definition (empty where the grammar has none).
|
||||
bases: Vec<String>,
|
||||
}
|
||||
|
||||
struct Built {
|
||||
@@ -221,6 +223,13 @@ fn collect(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Vec<Built>
|
||||
detail: detail.map(|d| clean(node_text(&d, text), 80)).filter(|d| !d.is_empty()),
|
||||
visibility: explicit_visibility(&node, text),
|
||||
trait_impl,
|
||||
// The index needs every class's bases; Python is the grammar that has them.
|
||||
bases: match kind {
|
||||
ItemKind::Symbol(SymbolKind::Class) if g.spec.name == "python" => {
|
||||
super::inheritance::class_base_names(node, text)
|
||||
}
|
||||
_ => Vec::new(),
|
||||
},
|
||||
};
|
||||
match by_node.get(&raw.node_id) {
|
||||
Some(existing) if existing.pattern <= raw.pattern => {}
|
||||
@@ -369,6 +378,7 @@ pub(crate) fn tags(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Ve
|
||||
kind: b.kind,
|
||||
container: own_container.map(str::to_owned),
|
||||
range: b.raw.sel,
|
||||
bases: b.raw.bases.clone(),
|
||||
});
|
||||
}
|
||||
let next = if b.raw.tag || matches!(b.raw.kind, ItemKind::Impl | ItemKind::Extension) {
|
||||
|
||||
@@ -1422,6 +1422,35 @@ fn spelling_regions_cover_declared_names_only() {
|
||||
assert_eq!(names, ["Bird", "fly", "text"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spelling_regions_mark_raw_strings() {
|
||||
let py = r#"a = r"\user" + R'\mesage' + fr"\wrd" + rb"\foo" + "\user""#;
|
||||
let found: Vec<(&str, bool)> = syntax()
|
||||
.spelling_regions(&lang("python"), py)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.filter(|r| r.kind == SpellingKind::String)
|
||||
.map(|r| (&py[r.start..r.end], r.raw))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
found,
|
||||
vec![
|
||||
(r#"r"\user""#, true),
|
||||
(r"R'\mesage'", true),
|
||||
(r#"fr"\wrd""#, true),
|
||||
(r#"rb"\foo""#, true),
|
||||
(r#""\user""#, false),
|
||||
]
|
||||
);
|
||||
// C# verbatim / Rust raw literals are named by the grammar itself.
|
||||
let cs = r#"var s = @"C:\mesage";"#;
|
||||
let raw = syntax().spelling_regions(&lang("csharp"), cs).unwrap().iter().any(|r| r.raw);
|
||||
assert!(raw, "C# verbatim string should be raw");
|
||||
let rs = r#"let s = r"\mesage";"#;
|
||||
let raw = syntax().spelling_regions(&lang("rust"), rs).unwrap().iter().any(|r| r.raw);
|
||||
assert!(raw, "Rust raw string should be raw");
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Script regions of Vue SFCs and HTML documents
|
||||
|
||||
|
||||
@@ -129,7 +129,7 @@ pub(crate) fn definitions(g: &Grammar, css: Option<&Grammar>, tree: &Tree, text:
|
||||
};
|
||||
if let Some((name, kind)) = def {
|
||||
let range = idx.range(base + n.start_byte(), base + n.end_byte());
|
||||
out.push(SymbolTag { name, kind, container: None, range });
|
||||
out.push(SymbolTag { name, kind, container: None, range, bases: Vec::new() });
|
||||
}
|
||||
true
|
||||
});
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
doctrine-mapping.xsd is from Doctrine ORM (https://github.com/doctrine/orm),
|
||||
MIT License. Copyright (c) Doctrine Project.
|
||||
The copy published at https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd
|
||||
is broken (wrong targetNamespace / XMLSchema URI after an http→https rewrite);
|
||||
this file is the upstream schema with the correct namespace.
|
||||
@@ -0,0 +1,643 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
|
||||
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
|
||||
targetNamespace="http://doctrine-project.org/schemas/orm/doctrine-mapping"
|
||||
xmlns:orm="http://doctrine-project.org/schemas/orm/doctrine-mapping"
|
||||
elementFormDefault="qualified">
|
||||
|
||||
<xs:annotation>
|
||||
<xs:documentation><![CDATA[
|
||||
This is the XML Schema for the object/relational
|
||||
mapping file used by the Doctrine ORM.
|
||||
]]></xs:documentation>
|
||||
</xs:annotation>
|
||||
|
||||
<xs:element name="doctrine-mapping">
|
||||
<xs:complexType>
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="mapped-superclass" type="orm:mapped-superclass" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="entity" type="orm:entity" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="embeddable" type="orm:embeddable" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
</xs:element>
|
||||
|
||||
<xs:complexType name="emptyType">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="cascade-type">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cascade-all" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:element name="cascade-persist" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:element name="cascade-merge" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:element name="cascade-remove" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:element name="cascade-refresh" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:element name="cascade-detach" type="orm:emptyType" minOccurs="0"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="lifecycle-callback-type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="prePersist"/>
|
||||
<xs:enumeration value="postPersist"/>
|
||||
<xs:enumeration value="preUpdate"/>
|
||||
<xs:enumeration value="postUpdate"/>
|
||||
<xs:enumeration value="preRemove"/>
|
||||
<xs:enumeration value="postRemove"/>
|
||||
<xs:enumeration value="postLoad"/>
|
||||
<xs:enumeration value="preFlush"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="cache-usage-type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="READ_ONLY"/>
|
||||
<xs:enumeration value="READ_WRITE"/>
|
||||
<xs:enumeration value="NONSTRICT_READ_WRITE"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:complexType name="lifecycle-callback">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="type" type="orm:lifecycle-callback-type" use="required" />
|
||||
<xs:attribute name="method" type="xs:NMTOKEN" use="required" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="lifecycle-callbacks">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="lifecycle-callback" type="orm:lifecycle-callback" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="named-query">
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="query" type="xs:string" use="required" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="named-queries">
|
||||
<xs:sequence>
|
||||
<xs:element name="named-query" type="orm:named-query" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="named-native-query">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="query" type="xs:string" minOccurs="1" maxOccurs="1"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="result-class" type="orm:fqcn" />
|
||||
<xs:attribute name="result-set-mapping" type="xs:string" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="named-native-queries">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="named-native-query" type="orm:named-native-query" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="entity-listener">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="lifecycle-callback" type="orm:lifecycle-callback" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="class" type="orm:fqcn"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="entity-listeners">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="entity-listener" type="orm:entity-listener" minOccurs="1" maxOccurs="unbounded" />
|
||||
</xs:choice>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="column-result">
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="field-result">
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="column" type="xs:string" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="entity-result">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="field-result" type="orm:field-result" minOccurs="0" maxOccurs="unbounded" />
|
||||
</xs:choice>
|
||||
<xs:attribute name="entity-class" type="orm:fqcn" use="required" />
|
||||
<xs:attribute name="discriminator-column" type="xs:string" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="sql-result-set-mapping">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="entity-result" type="orm:entity-result"/>
|
||||
<xs:element name="column-result" type="orm:column-result"/>
|
||||
</xs:choice>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="sql-result-set-mappings">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="sql-result-set-mapping" type="orm:sql-result-set-mapping" minOccurs="1" maxOccurs="unbounded" />
|
||||
</xs:choice>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="cache">
|
||||
<xs:attribute name="usage" type="orm:cache-usage-type" />
|
||||
<xs:attribute name="region" type="xs:string" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="entity">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:element name="indexes" type="orm:indexes" minOccurs="0"/>
|
||||
<xs:element name="unique-constraints" type="orm:unique-constraints" minOccurs="0"/>
|
||||
<xs:element name="discriminator-column" type="orm:discriminator-column" minOccurs="0"/>
|
||||
<xs:element name="discriminator-map" type="orm:discriminator-map" minOccurs="0"/>
|
||||
<xs:element name="lifecycle-callbacks" type="orm:lifecycle-callbacks" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="entity-listeners" type="orm:entity-listeners" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="named-queries" type="orm:named-queries" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="named-native-queries" type="orm:named-native-queries" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="sql-result-set-mappings" type="orm:sql-result-set-mappings" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="id" type="orm:id" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="field" type="orm:field" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xs:element name="embedded" type="orm:embedded" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xs:element name="one-to-one" type="orm:one-to-one" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xs:element name="one-to-many" type="orm:one-to-many" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="many-to-one" type="orm:many-to-one" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="many-to-many" type="orm:many-to-many" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="association-overrides" type="orm:association-overrides" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:element name="attribute-overrides" type="orm:attribute-overrides" minOccurs="0" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="table" type="orm:tablename" />
|
||||
<xs:attribute name="schema" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="repository-class" type="orm:fqcn"/>
|
||||
<xs:attribute name="inheritance-type" type="orm:inheritance-type"/>
|
||||
<xs:attribute name="change-tracking-policy" type="orm:change-tracking-policy" />
|
||||
<xs:attribute name="read-only" type="xs:boolean" default="false" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="tablename" id="tablename">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:pattern value="[a-zA-Z_u01-uff.]+" id="tablename.pattern">
|
||||
</xs:pattern>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:complexType name="option" mixed="true">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="option" type="orm:option"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required"/>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="options">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="option" type="orm:option" minOccurs="0" maxOccurs="unbounded"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="mapped-superclass" >
|
||||
<xs:complexContent>
|
||||
<xs:extension base="orm:entity"/>
|
||||
</xs:complexContent>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="embeddable">
|
||||
<xs:complexContent>
|
||||
<xs:extension base="orm:entity"/>
|
||||
</xs:complexContent>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="change-tracking-policy">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="DEFERRED_IMPLICIT"/>
|
||||
<xs:enumeration value="DEFERRED_EXPLICIT"/>
|
||||
<xs:enumeration value="NOTIFY"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="inheritance-type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="SINGLE_TABLE"/>
|
||||
<xs:enumeration value="JOINED"/>
|
||||
<xs:enumeration value="TABLE_PER_CLASS"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="generator-strategy">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="NONE"/>
|
||||
<xs:enumeration value="SEQUENCE"/>
|
||||
<xs:enumeration value="IDENTITY"/>
|
||||
<xs:enumeration value="AUTO"/>
|
||||
<xs:enumeration value="UUID"/>
|
||||
<xs:enumeration value="CUSTOM" />
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="fk-action">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="CASCADE"/>
|
||||
<xs:enumeration value="RESTRICT"/>
|
||||
<xs:enumeration value="SET NULL"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="fetch-type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="EAGER"/>
|
||||
<xs:enumeration value="LAZY"/>
|
||||
<xs:enumeration value="EXTRA_LAZY"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="generated-type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="NEVER"/>
|
||||
<xs:enumeration value="INSERT"/>
|
||||
<xs:enumeration value="ALWAYS"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:complexType name="field">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="type" type="orm:type" default="string" />
|
||||
<xs:attribute name="column" type="orm:columntoken" />
|
||||
<xs:attribute name="length" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="unique" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="nullable" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="insertable" type="xs:boolean" default="true" />
|
||||
<xs:attribute name="updatable" type="xs:boolean" default="true" />
|
||||
<xs:attribute name="generated" type="orm:generated-type" default="NEVER" />
|
||||
<xs:attribute name="enum-type" type="xs:string" />
|
||||
<xs:attribute name="version" type="xs:boolean" />
|
||||
<xs:attribute name="column-definition" type="xs:string" />
|
||||
<xs:attribute name="precision" type="xs:integer" use="optional" />
|
||||
<xs:attribute name="scale" type="xs:integer" use="optional" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="embedded">
|
||||
<xs:sequence>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:sequence>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="class" type="orm:fqcn" use="optional" />
|
||||
<xs:attribute name="column-prefix" type="xs:string" use="optional" />
|
||||
<xs:attribute name="use-column-prefix" type="xs:boolean" default="true" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="discriminator-column">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="type" type="xs:NMTOKEN"/>
|
||||
<xs:attribute name="field-name" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="length" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="column-definition" type="xs:string" />
|
||||
<xs:attribute name="enum-type" type="xs:string" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="unique-constraint">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="optional"/>
|
||||
<xs:attribute name="columns" type="xs:string" use="optional"/>
|
||||
<xs:attribute name="fields" type="xs:string" use="optional"/>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="unique-constraints">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="unique-constraint" type="orm:unique-constraint" minOccurs="1" maxOccurs="unbounded"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="index">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="optional"/>
|
||||
<xs:attribute name="columns" type="xs:string" use="optional"/>
|
||||
<xs:attribute name="fields" type="xs:string" use="optional"/>
|
||||
<xs:attribute name="flags" type="xs:string" use="optional"/>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="indexes">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="index" type="orm:index" minOccurs="1" maxOccurs="unbounded"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="discriminator-mapping">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="value" type="orm:type" use="required"/>
|
||||
<xs:attribute name="class" type="orm:fqcn" use="required"/>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="discriminator-map">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="discriminator-mapping" type="orm:discriminator-mapping" minOccurs="1" maxOccurs="unbounded"/>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="generator">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="strategy" type="orm:generator-strategy" use="optional" default="AUTO" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="id">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="generator" type="orm:generator" minOccurs="0" />
|
||||
<xs:element name="sequence-generator" type="orm:sequence-generator" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="custom-id-generator" type="orm:custom-id-generator" minOccurs="0" maxOccurs="1" />
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="type" type="orm:type" />
|
||||
<xs:attribute name="column" type="orm:columntoken" />
|
||||
<xs:attribute name="length" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="association-key" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="column-definition" type="xs:string" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="sequence-generator">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="sequence-name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="allocation-size" type="xs:integer" use="optional" default="1" />
|
||||
<xs:attribute name="initial-value" type="xs:integer" use="optional" default="1" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="custom-id-generator">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="class" type="orm:fqcn" use="required" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="fqcn" id="fqcn">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:pattern value="[a-zA-Z_u01-uff][a-zA-Z0-9_u01-uff]+" id="fqcn.pattern">
|
||||
</xs:pattern>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="type" id="type">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:pattern value="([a-zA-Z_u01-uff][a-zA-Z0-9_u01-uff]+)|(\c+)" id="type.class.pattern">
|
||||
</xs:pattern>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:complexType name="inverse-join-columns">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="join-column" type="orm:join-column" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="join-column">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="optional" />
|
||||
<xs:attribute name="referenced-column-name" type="xs:NMTOKEN" use="optional" default="id" />
|
||||
<xs:attribute name="unique" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="nullable" type="xs:boolean" default="true" />
|
||||
<xs:attribute name="on-delete" type="orm:fk-action" />
|
||||
<xs:attribute name="column-definition" type="xs:string" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="join-columns">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="join-column" type="orm:join-column" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="join-table">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="join-columns" type="orm:join-columns" />
|
||||
<xs:element name="inverse-join-columns" type="orm:join-columns" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="schema" type="xs:NMTOKEN" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="order-by">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="order-by-field" type="orm:order-by-field" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="order-by-field">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="direction" type="orm:order-by-direction" default="ASC" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="order-by-direction">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:enumeration value="ASC"/>
|
||||
<xs:enumeration value="DESC"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:simpleType name="columntoken" id="columntoken">
|
||||
<xs:restriction base="xs:token">
|
||||
<xs:pattern value="[-._:A-Za-z0-9`]+" id="columntoken.pattern"/>
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<xs:complexType name="many-to-many">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
|
||||
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
|
||||
<xs:element name="join-table" type="orm:join-table" minOccurs="0" />
|
||||
<xs:element name="order-by" type="orm:order-by" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="target-entity" type="xs:string" use="required" />
|
||||
<xs:attribute name="mapped-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="index-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
|
||||
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="one-to-many">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
|
||||
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
|
||||
<xs:element name="order-by" type="orm:order-by" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="target-entity" type="xs:string" use="required" />
|
||||
<xs:attribute name="mapped-by" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="index-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
|
||||
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="many-to-one">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
|
||||
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
|
||||
<xs:choice minOccurs="0" maxOccurs="1">
|
||||
<xs:element name="join-column" type="orm:join-column"/>
|
||||
<xs:element name="join-columns" type="orm:join-columns"/>
|
||||
</xs:choice>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="target-entity" type="xs:string" />
|
||||
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="one-to-one">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
|
||||
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
|
||||
<xs:choice minOccurs="0" maxOccurs="1">
|
||||
<xs:element name="join-column" type="orm:join-column"/>
|
||||
<xs:element name="join-columns" type="orm:join-columns"/>
|
||||
</xs:choice>
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="target-entity" type="xs:string" />
|
||||
<xs:attribute name="mapped-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
|
||||
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="association-overrides">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="association-override" type="orm:association-override" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="association-override">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="join-table" type="orm:join-table" minOccurs="0" />
|
||||
<xs:element name="join-columns" type="orm:join-columns" minOccurs="0" />
|
||||
<xs:element name="inversed-by" type="orm:inversed-by-override" minOccurs="0" maxOccurs="1" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
<xs:attribute name="fetch" type="orm:fetch-type" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="inversed-by-override">
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="attribute-overrides">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="attribute-override" type="orm:attribute-override" minOccurs="1" maxOccurs="unbounded" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="attribute-override">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="field" type="orm:attribute-override-field" minOccurs="1" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="attribute-override-field">
|
||||
<xs:choice minOccurs="0" maxOccurs="unbounded">
|
||||
<xs:element name="options" type="orm:options" minOccurs="0" />
|
||||
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
|
||||
</xs:choice>
|
||||
<xs:attribute name="type" type="orm:type" default="string" />
|
||||
<xs:attribute name="column" type="orm:columntoken" />
|
||||
<xs:attribute name="length" type="xs:NMTOKEN" />
|
||||
<xs:attribute name="unique" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="nullable" type="xs:boolean" default="false" />
|
||||
<xs:attribute name="insertable" type="xs:boolean" default="true" />
|
||||
<xs:attribute name="updateable" type="xs:boolean" default="true" />
|
||||
<xs:attribute name="version" type="xs:boolean" />
|
||||
<xs:attribute name="column-definition" type="xs:string" />
|
||||
<xs:attribute name="precision" type="xs:integer" use="optional" />
|
||||
<xs:attribute name="scale" type="xs:integer" use="optional" />
|
||||
<xs:anyAttribute namespace="##other"/>
|
||||
</xs:complexType>
|
||||
|
||||
</xs:schema>
|
||||
@@ -26,6 +26,7 @@ pub(crate) mod jvm_inspect;
|
||||
mod move_refactoring;
|
||||
pub(crate) mod reserved_names;
|
||||
mod signature;
|
||||
pub(crate) mod stream_trace;
|
||||
pub use formatter::configure_formatter;
|
||||
/// First start imports the Maven / Gradle model, which can take minutes.
|
||||
const READY_TIMEOUT: Duration = Duration::from_secs(240);
|
||||
|
||||
@@ -63,7 +63,7 @@ impl JdtJvmInspector {
|
||||
}
|
||||
|
||||
/// `VmTarget` is not `Serialize`: the field names here are the bundle's.
|
||||
fn target_json(target: &VmTarget) -> Value {
|
||||
pub(super) fn target_json(target: &VmTarget) -> Value {
|
||||
json!({
|
||||
"pid": target.pid,
|
||||
"host": target.attach_host,
|
||||
@@ -72,7 +72,7 @@ fn target_json(target: &VmTarget) -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
fn command_error(e: IdeError) -> InspectError {
|
||||
pub(super) fn command_error(e: IdeError) -> InspectError {
|
||||
if missing_bundle(&e) {
|
||||
InspectError::Unsupported("the JVM inspector bundle is not loaded".to_owned())
|
||||
} else {
|
||||
@@ -81,7 +81,7 @@ fn command_error(e: IdeError) -> InspectError {
|
||||
}
|
||||
|
||||
/// `{"ok": payload}` or `{"error": code, "detail": text}`.
|
||||
fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
|
||||
pub(super) fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
|
||||
if let Some(code) = reply.get("error").and_then(Value::as_str) {
|
||||
let detail = reply.get("detail").and_then(Value::as_str);
|
||||
return Err(match code {
|
||||
@@ -94,6 +94,11 @@ fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
|
||||
"classNotLoaded" => InspectError::ClassNotLoaded,
|
||||
"notSuspended" => InspectError::NotSuspended,
|
||||
"timedOut" => InspectError::TimedOut,
|
||||
"noSession" => InspectError::NoSession,
|
||||
"notAtChainStart" => InspectError::NotAtChainStart(detail.unwrap_or_default().to_owned()),
|
||||
"busy" => InspectError::Busy,
|
||||
"noTrace" => InspectError::NoTrace,
|
||||
"failed" | "badArgument" => InspectError::Failed(detail.unwrap_or(code).to_owned()),
|
||||
other => InspectError::Failed(match detail {
|
||||
Some(detail) => format!("{other}: {detail}"),
|
||||
None => other.to_owned(),
|
||||
|
||||
@@ -0,0 +1,246 @@
|
||||
//! [`StreamTracer`] over the `openidea.jvm.stream.*` commands of the JVM inspector bundle that runs
|
||||
//! inside jdtls (`java/jvm-inspect`).
|
||||
|
||||
use super::jvm_inspect::{command_error, decode, target_json};
|
||||
use crate::LspManager;
|
||||
use ide_jvm_inspect::{
|
||||
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
|
||||
TraceState, VmTarget,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde_json::{Value, json};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::time::timeout;
|
||||
|
||||
/// `wait` is held by the bundle for the `ms` it is given; the command times out this long after.
|
||||
const WAIT_SLACK: Duration = Duration::from_secs(10);
|
||||
const ABORT_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
const COMMAND_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
|
||||
/// Each record is previewed with at least one JDWP round trip (about 0.1 ms locally, far more
|
||||
/// over a remote attach).
|
||||
fn collect_timeout(records: u64) -> Duration {
|
||||
Duration::from_secs(60)
|
||||
.saturating_add(Duration::from_millis(5).saturating_mul(records.try_into().unwrap_or(u32::MAX)))
|
||||
}
|
||||
|
||||
pub struct JdtStreamTracer {
|
||||
lsp: Arc<LspManager>,
|
||||
/// A path inside the module whose jdtls runs the debug session.
|
||||
server: PathBuf,
|
||||
}
|
||||
|
||||
impl JdtStreamTracer {
|
||||
/// Deliberately without `JdtJvmInspector`'s turn: a `wait` that holds a JDT LS thread for
|
||||
/// seconds must not keep the memory view from reading while the trace runs.
|
||||
pub fn new(lsp: Arc<LspManager>, server: PathBuf) -> Self {
|
||||
Self { lsp, server }
|
||||
}
|
||||
|
||||
async fn call<T: DeserializeOwned>(
|
||||
&self,
|
||||
op: &str,
|
||||
target: &VmTarget,
|
||||
args: Value,
|
||||
limit: Duration,
|
||||
) -> Result<T, InspectError> {
|
||||
let command = format!("openidea.jvm.stream.{op}");
|
||||
let arguments = vec![target_json(target), args];
|
||||
let reply = timeout(limit, self.lsp.jdtls_command(&self.server, &command, arguments))
|
||||
.await
|
||||
.map_err(|_| InspectError::TimedOut)?
|
||||
.map_err(command_error)?;
|
||||
decode(reply)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Armed {
|
||||
trace_id: TraceId,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "state", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
enum WireState {
|
||||
Running {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
elapsed_ms: u64,
|
||||
},
|
||||
Parked {
|
||||
records: u64,
|
||||
dropped: u64,
|
||||
},
|
||||
Failed {
|
||||
#[serde(default)]
|
||||
detail: String,
|
||||
},
|
||||
Cancelled {
|
||||
#[serde(default)]
|
||||
detail: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl From<WireState> for TraceState {
|
||||
fn from(state: WireState) -> Self {
|
||||
match state {
|
||||
WireState::Running { records, dropped, elapsed_ms } => Self::Running { records, dropped, elapsed_ms },
|
||||
WireState::Parked { records, dropped } => Self::Parked { records, dropped },
|
||||
WireState::Failed { detail } => Self::Failed { detail },
|
||||
WireState::Cancelled { detail } => Self::Cancelled { detail },
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Stopped {
|
||||
records: u64,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "state", rename_all = "camelCase")]
|
||||
enum WireAbort {
|
||||
Interrupted,
|
||||
Stopped,
|
||||
Stuck {
|
||||
#[serde(default)]
|
||||
holders: Vec<Holder>,
|
||||
},
|
||||
Cancelled,
|
||||
Finished,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Holder {
|
||||
thread_id: i64,
|
||||
name: String,
|
||||
}
|
||||
|
||||
impl From<WireAbort> for AbortState {
|
||||
fn from(state: WireAbort) -> Self {
|
||||
match state {
|
||||
WireAbort::Interrupted => Self::Interrupted,
|
||||
WireAbort::Stopped => Self::Stopped,
|
||||
WireAbort::Stuck { holders } => {
|
||||
Self::Stuck { holders: holders.into_iter().map(|h| (h.thread_id, h.name)).collect() }
|
||||
}
|
||||
WireAbort::Cancelled => Self::Cancelled,
|
||||
WireAbort::Finished => Self::Finished,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct WireCollected {
|
||||
records: Vec<WireRecord>,
|
||||
dropped: u64,
|
||||
terminal: WireTerminal,
|
||||
skipped_breakpoints: u32,
|
||||
sequentialized: bool,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct WireRecord {
|
||||
step: u16,
|
||||
value: JvmValue,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "kind", rename_all = "camelCase")]
|
||||
enum WireTerminal {
|
||||
Value { value: JvmValue },
|
||||
Void,
|
||||
Threw { exception: JvmValue },
|
||||
}
|
||||
|
||||
impl From<WireCollected> for TraceCollected {
|
||||
fn from(wire: WireCollected) -> Self {
|
||||
Self {
|
||||
records: wire.records.into_iter().map(|r| (r.step, r.value)).collect(),
|
||||
dropped: wire.dropped,
|
||||
terminal: match wire.terminal {
|
||||
WireTerminal::Value { value } => CollectedTerminal::Value(value),
|
||||
WireTerminal::Void => CollectedTerminal::Void,
|
||||
WireTerminal::Threw { exception } => CollectedTerminal::Threw(exception),
|
||||
},
|
||||
skipped_breakpoints: wire.skipped_breakpoints,
|
||||
sequentialized: wire.sequentialized,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl StreamTracer for JdtStreamTracer {
|
||||
fn arm<'a>(
|
||||
&'a self,
|
||||
target: &'a VmTarget,
|
||||
thread_id: i64,
|
||||
plan: &'a Value,
|
||||
budget: u32,
|
||||
token: &'a str,
|
||||
) -> InspectFuture<'a, TraceId> {
|
||||
Box::pin(async move {
|
||||
let args = json!({"threadId": thread_id, "plan": plan, "budget": budget, "token": token});
|
||||
Ok(self.call::<Armed>("arm", target, args, COMMAND_TIMEOUT).await?.trace_id)
|
||||
})
|
||||
}
|
||||
|
||||
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState> {
|
||||
Box::pin(async move {
|
||||
let limit = Duration::from_millis(u64::from(ms)) + WAIT_SLACK;
|
||||
let state: WireState = self.call("wait", target, json!({"traceId": trace, "ms": ms}), limit).await?;
|
||||
Ok(state.into())
|
||||
})
|
||||
}
|
||||
|
||||
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64> {
|
||||
Box::pin(async move {
|
||||
Ok(self.call::<Stopped>("stop", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await?.records)
|
||||
})
|
||||
}
|
||||
|
||||
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState> {
|
||||
Box::pin(async move {
|
||||
let state: WireAbort = self.call("abort", target, json!({"traceId": trace}), ABORT_TIMEOUT).await?;
|
||||
Ok(state.into())
|
||||
})
|
||||
}
|
||||
|
||||
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
|
||||
Box::pin(async move {
|
||||
let limit = collect_timeout(records);
|
||||
let collected: WireCollected = self.call("collect", target, json!({"traceId": trace}), limit).await?;
|
||||
Ok(collected.into())
|
||||
})
|
||||
}
|
||||
|
||||
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()> {
|
||||
Box::pin(async move {
|
||||
self.call::<Value>("release", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await.map(drop)
|
||||
})
|
||||
}
|
||||
|
||||
fn release_armed<'a>(&'a self, target: &'a VmTarget, token: &'a str) -> InspectFuture<'a, ()> {
|
||||
Box::pin(async move {
|
||||
// Waits for an arm still setting up: as long as an arm may take.
|
||||
self.call::<Value>("release", target, json!({"token": token}), COMMAND_TIMEOUT).await.map(drop)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn collect_timeout_grows_with_the_records() {
|
||||
assert_eq!(collect_timeout(0), Duration::from_secs(60));
|
||||
assert_eq!(collect_timeout(50_000), Duration::from_secs(60 + 250));
|
||||
assert!(collect_timeout(u64::MAX) >= collect_timeout(50_000));
|
||||
}
|
||||
}
|
||||
@@ -40,10 +40,12 @@ mod uri;
|
||||
mod virtual_doc;
|
||||
mod vue_navigation;
|
||||
mod vue_refs;
|
||||
mod xml_catalog;
|
||||
|
||||
pub use injections::{InjectedRange, InjectionProvider, MAX_INJECTED_DOCUMENT_BYTES};
|
||||
pub use inspect::{CheckedServer, DocumentCheck, FileInspection, InspectHost, InspectOptions};
|
||||
pub use jdtls::jvm_inspect::JdtJvmInspector;
|
||||
pub use jdtls::stream_trace::JdtStreamTracer;
|
||||
pub use kotlin_lsp::{KotlinDebugServer, KotlinDebugUnavailable};
|
||||
pub use launch::{LaunchError, Launcher, ProcessLauncher};
|
||||
pub use notebook::{NotebookCell, NotebookCellDoc, cell_uri};
|
||||
@@ -3794,6 +3796,9 @@ impl LspManager {
|
||||
if cfg.name == compose::SERVER {
|
||||
compose::configure_yaml_compose_schemas(&mut cfg, &self.open_compose_files());
|
||||
}
|
||||
if cfg.name == xml_catalog::SERVER {
|
||||
xml_catalog::configure_lemminx_catalogs(&mut cfg);
|
||||
}
|
||||
cfg
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
//! Bundled XML catalogs for LemMinX so known-broken remote XSDs resolve locally.
|
||||
//!
|
||||
//! Doctrine's hosted `doctrine-mapping.xsd` advertises the wrong `targetNamespace`
|
||||
//! (the schema URL itself) after an http→https rewrite, so any mapping file that
|
||||
//! points `xsi:schemaLocation` at that URL fails with `TargetNamespace.1` /
|
||||
//! `cvc-elt.1.a`. An OASIS catalog maps the namespace and those system IDs to the
|
||||
//! correct upstream schema we ship.
|
||||
|
||||
use ide_language::LanguageServerConfig;
|
||||
use serde_json::{Value, json};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub const SERVER: &str = "lemminx";
|
||||
|
||||
const DOCTRINE_XSD: &str = include_str!("../schemas/xml/doctrine-mapping.xsd");
|
||||
|
||||
const CATALOG_TEMPLATE: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
|
||||
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
|
||||
<uri name="http://doctrine-project.org/schemas/orm/doctrine-mapping" uri="doctrine-mapping.xsd"/>
|
||||
<uri name="https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
|
||||
<system systemId="https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
|
||||
<system systemId="http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
|
||||
</catalog>
|
||||
"#;
|
||||
|
||||
/// Writes the bundled catalog (idempotent) and prepends it to LemMinX `xml.catalogs`.
|
||||
pub fn configure_lemminx_catalogs(cfg: &mut LanguageServerConfig) {
|
||||
if cfg.name != SERVER {
|
||||
return;
|
||||
}
|
||||
let Some(catalog) = ensure_catalog() else { return };
|
||||
let catalog = path_for_settings(&catalog);
|
||||
let mut settings = cfg.settings.take().filter(Value::is_object).unwrap_or_else(|| json!({}));
|
||||
let Some(root) = settings.as_object_mut() else {
|
||||
cfg.settings = Some(settings);
|
||||
return;
|
||||
};
|
||||
let Some(xml) = root.entry("xml").or_insert_with(|| json!({})).as_object_mut() else {
|
||||
cfg.settings = Some(settings);
|
||||
return;
|
||||
};
|
||||
let Some(catalogs) = xml.entry("catalogs").or_insert_with(|| json!([])).as_array_mut() else {
|
||||
cfg.settings = Some(settings);
|
||||
return;
|
||||
};
|
||||
if catalogs.iter().any(|v| v.as_str() == Some(catalog.as_str())) {
|
||||
cfg.settings = Some(settings);
|
||||
return;
|
||||
}
|
||||
catalogs.insert(0, Value::String(catalog));
|
||||
cfg.settings = Some(settings);
|
||||
}
|
||||
|
||||
fn ensure_catalog() -> Option<PathBuf> {
|
||||
// Per-pid directory: shared `/tmp/openidea-xml-catalog` would let another
|
||||
// local user plant a catalog that remaps arbitrary schema URIs.
|
||||
let dir = std::env::temp_dir().join(format!("openidea-xml-catalog-{}", std::process::id()));
|
||||
if let Err(e) = ide_vfs::create_private_dir(&dir) {
|
||||
tracing::warn!("xml catalog: cannot create {}: {e}", dir.display());
|
||||
return None;
|
||||
}
|
||||
let xsd = dir.join("doctrine-mapping.xsd");
|
||||
if !write_if_changed(&xsd, DOCTRINE_XSD.as_bytes()) {
|
||||
tracing::warn!("xml catalog: cannot write {}", xsd.display());
|
||||
return None;
|
||||
}
|
||||
let catalog = dir.join("catalog.xml");
|
||||
if !write_if_changed(&catalog, CATALOG_TEMPLATE.as_bytes()) {
|
||||
tracing::warn!("xml catalog: cannot write {}", catalog.display());
|
||||
return None;
|
||||
}
|
||||
Some(catalog)
|
||||
}
|
||||
|
||||
fn write_if_changed(path: &Path, bytes: &[u8]) -> bool {
|
||||
if std::fs::read(path).ok().as_deref() == Some(bytes) {
|
||||
return true;
|
||||
}
|
||||
ide_vfs::write_atomic_private(path, bytes).is_ok()
|
||||
}
|
||||
|
||||
fn path_for_settings(path: &Path) -> String {
|
||||
path.to_string_lossy().replace('\\', "/")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_language::LanguageRegistry;
|
||||
|
||||
const DOCTRINE_NS: &str = "http://doctrine-project.org/schemas/orm/doctrine-mapping";
|
||||
const DOCTRINE_SCHEMA_HTTPS: &str = "https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd";
|
||||
const DOCTRINE_SCHEMA_HTTP: &str = "http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd";
|
||||
|
||||
#[test]
|
||||
fn bundled_xsd_keeps_http_namespace() {
|
||||
assert!(DOCTRINE_XSD.contains(&format!("targetNamespace=\"{DOCTRINE_NS}\"")));
|
||||
assert!(!DOCTRINE_XSD.contains("xmlns:xs=\"https://www.w3.org/2001/XMLSchema\""));
|
||||
assert!(!DOCTRINE_XSD.contains("targetNamespace=\"https://www.doctrine-project.org"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn catalog_maps_namespace_and_system_ids() {
|
||||
assert!(CATALOG_TEMPLATE.contains(&format!(r#"name="{DOCTRINE_NS}""#)));
|
||||
assert!(CATALOG_TEMPLATE.contains(&format!(r#"name="{DOCTRINE_SCHEMA_HTTPS}""#)));
|
||||
assert!(CATALOG_TEMPLATE.contains(&format!(r#"systemId="{DOCTRINE_SCHEMA_HTTPS}""#)));
|
||||
assert!(CATALOG_TEMPLATE.contains(&format!(r#"systemId="{DOCTRINE_SCHEMA_HTTP}""#)));
|
||||
assert_eq!(CATALOG_TEMPLATE.matches(r#"uri="doctrine-mapping.xsd""#).count(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepends_catalog_without_dropping_user_entries() {
|
||||
let reg = LanguageRegistry::load(None).unwrap();
|
||||
let xml = reg.get(&ide_core::LanguageId::new("xml")).unwrap();
|
||||
let mut cfg = xml.language_servers[0].clone();
|
||||
cfg.settings = Some(json!({"xml": {"catalogs": ["/user/catalog.xml"]}}));
|
||||
configure_lemminx_catalogs(&mut cfg);
|
||||
let list: Vec<String> = cfg.settings.as_ref().unwrap()["xml"]["catalogs"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(str::to_owned)
|
||||
.collect();
|
||||
assert_eq!(list.len(), 2);
|
||||
assert!(list[0].ends_with("catalog.xml"));
|
||||
assert!(list[0].contains(&format!("openidea-xml-catalog-{}", std::process::id())));
|
||||
assert_eq!(list[1], "/user/catalog.xml");
|
||||
configure_lemminx_catalogs(&mut cfg);
|
||||
assert_eq!(cfg.settings.as_ref().unwrap()["xml"]["catalogs"].as_array().unwrap().len(), 2);
|
||||
|
||||
let catalog = PathBuf::from(&list[0]);
|
||||
let body = std::fs::read_to_string(&catalog).unwrap();
|
||||
assert_eq!(body, CATALOG_TEMPLATE);
|
||||
assert!(body.contains(&format!(r#"name="{DOCTRINE_NS}""#)));
|
||||
let xsd = catalog.with_file_name("doctrine-mapping.xsd");
|
||||
assert_eq!(std::fs::read_to_string(xsd).unwrap(), DOCTRINE_XSD);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_other_servers() {
|
||||
let reg = LanguageRegistry::load(None).unwrap();
|
||||
let yaml = reg.get(&ide_core::LanguageId::new("yaml")).unwrap();
|
||||
let mut cfg = yaml.language_servers[0].clone();
|
||||
let before = cfg.settings.clone();
|
||||
configure_lemminx_catalogs(&mut cfg);
|
||||
assert_eq!(cfg.settings, before);
|
||||
}
|
||||
}
|
||||
@@ -324,6 +324,7 @@ fn harness_languages(languages: &[MockLanguage<'_>], adjust: impl Fn(&mut Langua
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: servers
|
||||
.iter()
|
||||
@@ -3170,6 +3171,228 @@ async fn jvm_inspect_sends_one_command_at_a_time() {
|
||||
assert_eq!(most.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
async fn stream_harness() -> (Harness, Arc<MockState>, ide_lsp::JdtStreamTracer) {
|
||||
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
|
||||
let (_, path) = h.open("Sample.java", "class Sample {}");
|
||||
h.wait_status("jdtls", ServerStatus::Ready).await;
|
||||
let tracer = ide_lsp::JdtStreamTracer::new(h.mgr.clone(), path);
|
||||
let state = h.launcher.state("jdtls");
|
||||
(h, state, tracer)
|
||||
}
|
||||
|
||||
fn stream_launch_target() -> ide_jvm_inspect::VmTarget {
|
||||
ide_jvm_inspect::VmTarget { pid: Some(42), attach_host: None, attach_port: None, generation: 3 }
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_commands_send_target_then_named_fields() {
|
||||
use ide_jvm_inspect::StreamTracer;
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
let target = stream_launch_target();
|
||||
let target_json = json!({"pid": 42, "host": null, "port": null, "generation": 3});
|
||||
let plan = json!({"root": {"line": 14}});
|
||||
|
||||
s.respond("workspace/executeCommand", json!({"ok": {"traceId": 3}}));
|
||||
assert_eq!(tracer.arm(&target, 7, &plan, 500, "t1").await.unwrap(), 3);
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {"state": "running", "records": 1, "dropped": 0, "elapsedMs": 2}}),
|
||||
);
|
||||
tracer.wait(&target, 3, 250).await.unwrap();
|
||||
s.respond("workspace/executeCommand", json!({"ok": {"records": 9}}));
|
||||
assert_eq!(tracer.stop(&target, 3).await.unwrap(), 9);
|
||||
s.respond("workspace/executeCommand", json!({"ok": {"state": "stopped"}}));
|
||||
tracer.abort(&target, 3).await.unwrap();
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"}, "skippedBreakpoints": 0,
|
||||
"sequentialized": false}}),
|
||||
);
|
||||
tracer.collect(&target, 3, 2).await.unwrap();
|
||||
s.respond("workspace/executeCommand", json!({"ok": {}}));
|
||||
tracer.release(&target, 3).await.unwrap();
|
||||
s.respond("workspace/executeCommand", json!({"ok": {}}));
|
||||
tracer.release_armed(&target, "t1").await.unwrap();
|
||||
|
||||
let asked = s.requested("workspace/executeCommand");
|
||||
let seen: Vec<_> = asked.iter().map(|p| (p["command"].clone(), p["arguments"].clone())).collect();
|
||||
assert_eq!(
|
||||
seen,
|
||||
vec![
|
||||
(
|
||||
json!("openidea.jvm.stream.arm"),
|
||||
json!([target_json, {"threadId": 7, "plan": plan, "budget": 500, "token": "t1"}])
|
||||
),
|
||||
(json!("openidea.jvm.stream.wait"), json!([target_json, {"traceId": 3, "ms": 250}])),
|
||||
(json!("openidea.jvm.stream.stop"), json!([target_json, {"traceId": 3}])),
|
||||
(json!("openidea.jvm.stream.abort"), json!([target_json, {"traceId": 3}])),
|
||||
(json!("openidea.jvm.stream.collect"), json!([target_json, {"traceId": 3}])),
|
||||
(json!("openidea.jvm.stream.release"), json!([target_json, {"traceId": 3}])),
|
||||
(json!("openidea.jvm.stream.release"), json!([target_json, {"token": "t1"}])),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_wait_decodes_states() {
|
||||
use ide_jvm_inspect::{StreamTracer, TraceState};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
let target = stream_launch_target();
|
||||
let cases = [
|
||||
(
|
||||
json!({"state": "running", "records": 10, "dropped": 0, "elapsedMs": 5}),
|
||||
TraceState::Running { records: 10, dropped: 0, elapsed_ms: 5 },
|
||||
),
|
||||
(
|
||||
json!({"state": "parked", "records": 50000, "dropped": 950000, "elapsedMs": 96}),
|
||||
TraceState::Parked { records: 50000, dropped: 950000 },
|
||||
),
|
||||
(
|
||||
json!({"state": "failed", "records": 4, "dropped": 0, "elapsedMs": 12, "detail": "missed map"}),
|
||||
TraceState::Failed { detail: "missed map".into() },
|
||||
),
|
||||
(
|
||||
json!({"state": "cancelled", "records": 0, "dropped": 0, "elapsedMs": 12,
|
||||
"detail": "cancelled before the terminal ran"}),
|
||||
TraceState::Cancelled { detail: "cancelled before the terminal ran".into() },
|
||||
),
|
||||
];
|
||||
for (ok, expected) in cases {
|
||||
s.respond("workspace/executeCommand", json!({"ok": ok}));
|
||||
assert_eq!(tracer.wait(&target, 1, 10).await.unwrap(), expected, "{ok}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_abort_decodes_every_state() {
|
||||
use ide_jvm_inspect::{AbortState, StreamTracer};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
let target = stream_launch_target();
|
||||
let cases = [
|
||||
(json!({"state": "interrupted"}), AbortState::Interrupted),
|
||||
(json!({"state": "stopped"}), AbortState::Stopped),
|
||||
(
|
||||
json!({"state": "stuck", "holders": [{"threadId": 42, "name": "worker-1"}]}),
|
||||
AbortState::Stuck { holders: vec![(42, "worker-1".into())] },
|
||||
),
|
||||
(json!({"state": "cancelled"}), AbortState::Cancelled),
|
||||
(json!({"state": "finished"}), AbortState::Finished),
|
||||
];
|
||||
for (ok, expected) in cases {
|
||||
s.respond("workspace/executeCommand", json!({"ok": ok}));
|
||||
assert_eq!(tracer.abort(&target, 1).await.unwrap(), expected, "{ok}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_errors_map() {
|
||||
use ide_jvm_inspect::{InspectError, StreamTracer};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
let target = stream_launch_target();
|
||||
let cases = [
|
||||
(
|
||||
json!({"error": "notAtChainStart", "detail": "line 14 is not where the statement starts"}),
|
||||
InspectError::NotAtChainStart("line 14 is not where the statement starts".into()),
|
||||
),
|
||||
(json!({"error": "busy", "detail": "trace 2 is running"}), InspectError::Busy),
|
||||
(json!({"error": "noTrace", "detail": "no trace 9 on this VM"}), InspectError::NoTrace),
|
||||
(json!({"error": "noSession", "detail": "x"}), InspectError::NoSession),
|
||||
(json!({"error": "stale", "detail": "no thread 77"}), InspectError::Stale),
|
||||
(json!({"error": "notSuspended", "detail": "thread 1 is running"}), InspectError::NotSuspended),
|
||||
(json!({"error": "unsupported", "detail": "xs is a List"}), InspectError::Unsupported("xs is a List".into())),
|
||||
(
|
||||
json!({"error": "badArgument", "detail": "budget must be 1 or more"}),
|
||||
InspectError::Failed("budget must be 1 or more".into()),
|
||||
),
|
||||
(json!({"error": "failed", "detail": "missed filter"}), InspectError::Failed("missed filter".into())),
|
||||
(json!({"error": "surprise", "detail": "d"}), InspectError::Failed("surprise: d".into())),
|
||||
];
|
||||
for (reply, expected) in cases {
|
||||
s.respond("workspace/executeCommand", reply.clone());
|
||||
assert_eq!(tracer.arm(&target, 1, &json!({}), 10, "t").await.unwrap_err(), expected, "{reply}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_missing_bundle_is_unsupported() {
|
||||
use ide_jvm_inspect::{InspectError, StreamTracer};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
s.errors.lock().insert(
|
||||
"workspace/executeCommand".into(),
|
||||
(-32603, "No delegateCommandHandler for openidea.jvm.stream.wait".into()),
|
||||
);
|
||||
assert_eq!(
|
||||
tracer.wait(&stream_launch_target(), 1, 10).await.unwrap_err(),
|
||||
InspectError::Unsupported("the JVM inspector bundle is not loaded".into())
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_collect_decodes() {
|
||||
use ide_jvm_inspect::{CollectedTerminal, JvmValue, StreamTracer};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
let target = stream_launch_target();
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {
|
||||
"records": [
|
||||
{"step": 0, "value": {"kind": "boxed", "id": 1, "typeName": "java.lang.Integer", "text": "5"}},
|
||||
{"step": 1, "value": {"kind": "string", "id": 2, "text": "5", "length": 1}},
|
||||
],
|
||||
"dropped": 4,
|
||||
"terminal": {"kind": "threw",
|
||||
"exception": {"kind": "object", "id": 9, "typeName": "java.lang.ArithmeticException"}},
|
||||
"skippedBreakpoints": 1,
|
||||
"sequentialized": true,
|
||||
}}),
|
||||
);
|
||||
let collected = tracer.collect(&target, 3, 2).await.unwrap();
|
||||
assert_eq!(
|
||||
collected.records,
|
||||
vec![
|
||||
(0, JvmValue::Boxed { id: 1, type_name: "java.lang.Integer".into(), text: "5".into() }),
|
||||
(1, JvmValue::Str { id: 2, text: Some("5".into()), length: 1 }),
|
||||
]
|
||||
);
|
||||
assert_eq!(collected.dropped, 4);
|
||||
assert_eq!(
|
||||
collected.terminal,
|
||||
CollectedTerminal::Threw(JvmValue::Object { id: 9, type_name: "java.lang.ArithmeticException".into() })
|
||||
);
|
||||
assert_eq!(collected.skipped_breakpoints, 1);
|
||||
assert!(collected.sequentialized);
|
||||
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {"records": [], "dropped": 0,
|
||||
"terminal": {"kind": "value", "value": {"kind": "object", "id": 19, "typeName": "java.util.ArrayList"}},
|
||||
"skippedBreakpoints": 0, "sequentialized": false}}),
|
||||
);
|
||||
assert_eq!(
|
||||
tracer.collect(&target, 3, 2).await.unwrap().terminal,
|
||||
CollectedTerminal::Value(JvmValue::Object { id: 19, type_name: "java.util.ArrayList".into() })
|
||||
);
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"},
|
||||
"skippedBreakpoints": 0, "sequentialized": false}}),
|
||||
);
|
||||
assert_eq!(tracer.collect(&target, 3, 2).await.unwrap().terminal, CollectedTerminal::Void);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn stream_collect_fails_cleanly_on_a_step_beyond_u16() {
|
||||
use ide_jvm_inspect::{InspectError, StreamTracer};
|
||||
let (_h, s, tracer) = stream_harness().await;
|
||||
s.respond(
|
||||
"workspace/executeCommand",
|
||||
json!({"ok": {"records": [{"step": 70000, "value": {"kind": "null"}}], "dropped": 0,
|
||||
"terminal": {"kind": "void"}, "skippedBreakpoints": 0, "sequentialized": false}}),
|
||||
);
|
||||
let error = tracer.collect(&stream_launch_target(), 3, 2).await.unwrap_err();
|
||||
assert!(matches!(error, InspectError::Failed(ref m) if m.contains("malformed")), "{error:?}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn debug_server_port_maps_to_module() {
|
||||
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
|
||||
|
||||
@@ -58,6 +58,7 @@ fn lang(id: &str, ext: &str, server: LanguageServerConfig) -> LanguageConfig {
|
||||
framework_files: Vec::new(),
|
||||
formatter: None,
|
||||
scratch_template: None,
|
||||
rainbow_brackets: Default::default(),
|
||||
tree_sitter: None,
|
||||
language_servers: vec![server],
|
||||
debugger: None,
|
||||
|
||||
@@ -38,6 +38,29 @@ pub struct ContentDiff {
|
||||
pub title: Option<String>,
|
||||
}
|
||||
|
||||
/// A diff opened by a plugin (API 1.10): `None` is a side where the file doesn't exist.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct FileDiff {
|
||||
pub left: Option<String>,
|
||||
pub right: Option<String>,
|
||||
pub left_label: Option<String>,
|
||||
pub right_label: Option<String>,
|
||||
pub title: Option<String>,
|
||||
}
|
||||
|
||||
impl From<ContentDiff> for FileDiff {
|
||||
fn from(v: ContentDiff) -> Self {
|
||||
Self {
|
||||
left: Some(v.left),
|
||||
right: Some(v.right),
|
||||
left_label: v.left_label,
|
||||
right_label: v.right_label,
|
||||
title: v.title,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// ContentTabReply data exchanged with the IDE.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -56,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
|
||||
use views_bindings::openidea::plugin::view_types as wit_vt;
|
||||
|
||||
/// The API version of the world above, `major.minor` of [`host_api`].
|
||||
pub const API_VERSION: &str = "1.9";
|
||||
pub const API_VERSION: &str = "1.10";
|
||||
const EPOCH_TICK: Duration = Duration::from_millis(10);
|
||||
pub(crate) const MAX_TEXT: usize = 1 << 20;
|
||||
pub(crate) const MAX_TITLE: usize = 256;
|
||||
@@ -117,6 +117,13 @@ pub trait HostApi: Send + Sync {
|
||||
let _ = (root, method, params, notify, cancel, timeout);
|
||||
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
|
||||
}
|
||||
/// The flat dependency graph of the Maven / Gradle builds of the project at `root`
|
||||
/// (of the module `module` only, when given), as the IDE last resolved it; never runs
|
||||
/// a build tool.
|
||||
fn build_dependencies(&self, root: &Path, module: Option<&str>) -> Result<Vec<crate::DependencyNode>, HostError> {
|
||||
let _ = (root, module);
|
||||
Err(HostError::Failed("build data is unavailable on this host".into()))
|
||||
}
|
||||
/// Stdio argv only; no URL or bearer token.
|
||||
fn mcp_stdio_command(&self, client: &str) -> Option<Vec<String>> {
|
||||
let _ = client;
|
||||
@@ -188,8 +195,8 @@ pub trait HostApi: Send + Sync {
|
||||
let _ = (client, tab, cancel, timeout);
|
||||
Err(HostError::Failed("content tabs unavailable".into()))
|
||||
}
|
||||
/// Opens a diff of two texts in the invoking window.
|
||||
fn open_diff(&self, client: &str, diff: crate::ContentDiff, file_name: Option<String>) -> Result<(), HostError> {
|
||||
/// Opens a diff of two texts in the invoking window; a `None` side doesn't exist.
|
||||
fn open_diff(&self, client: &str, diff: crate::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
|
||||
let _ = (client, diff, file_name);
|
||||
Err(HostError::Failed("diffs unavailable".into()))
|
||||
}
|
||||
|
||||
@@ -959,6 +959,28 @@ pub struct BlameLine {
|
||||
pub summary: String,
|
||||
}
|
||||
|
||||
/// How an occurrence in a build's dependency graph was resolved (API 1.10).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum DependencyStatus {
|
||||
Resolved,
|
||||
OmittedForConflict,
|
||||
OmittedForDuplicate,
|
||||
VersionManaged,
|
||||
}
|
||||
|
||||
/// One occurrence in the flat dependency graph of `build.dependencies` (API 1.10);
|
||||
/// `parent` indexes the list.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct DependencyNode {
|
||||
pub group: String,
|
||||
pub artifact: String,
|
||||
pub version: String,
|
||||
pub scope: String,
|
||||
pub status: DependencyStatus,
|
||||
pub requested_version: Option<String>,
|
||||
pub parent: Option<u32>,
|
||||
}
|
||||
|
||||
/// Non-secret settings of a plugin-owned project database source (API 1.4).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
|
||||
@@ -48,6 +48,7 @@ pub(crate) mod syntax_bindings {
|
||||
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
|
||||
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
|
||||
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
|
||||
"openidea:plugin/build": super::bindings::openidea::plugin::build,
|
||||
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
|
||||
"openidea:plugin/events": super::bindings::openidea::plugin::events,
|
||||
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
|
||||
@@ -87,6 +88,7 @@ pub(crate) mod providers_bindings {
|
||||
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
|
||||
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
|
||||
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
|
||||
"openidea:plugin/build": super::bindings::openidea::plugin::build,
|
||||
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
|
||||
"openidea:plugin/events": super::bindings::openidea::plugin::events,
|
||||
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
|
||||
@@ -126,6 +128,7 @@ pub(crate) mod views_bindings {
|
||||
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
|
||||
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
|
||||
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
|
||||
"openidea:plugin/build": super::bindings::openidea::plugin::build,
|
||||
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
|
||||
"openidea:plugin/events": super::bindings::openidea::plugin::events,
|
||||
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
|
||||
@@ -150,8 +153,8 @@ pub(crate) mod views_bindings {
|
||||
}
|
||||
|
||||
use bindings::openidea::plugin::{
|
||||
commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets, settings,
|
||||
storage, tasks, types as wit, ui, vcs, views, workspace,
|
||||
build, commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets,
|
||||
settings, storage, tasks, types as wit, ui, vcs, views, workspace,
|
||||
};
|
||||
|
||||
/// A project handle: its root.
|
||||
@@ -1192,6 +1195,44 @@ impl vcs::Host for StoreData {
|
||||
}
|
||||
}
|
||||
|
||||
impl build::Host for StoreData {
|
||||
fn dependencies(
|
||||
&mut self,
|
||||
project: Resource<ProjectRes>,
|
||||
module: Option<String>,
|
||||
) -> Fallible<Vec<build::DependencyNode>> {
|
||||
if let Err(e) = self.require(Capability::BuildRead) {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
let root = self.table.get(&project)?.root.clone();
|
||||
Ok(self
|
||||
.host
|
||||
.build_dependencies(&root, module.as_deref())
|
||||
.map(|nodes| {
|
||||
nodes
|
||||
.into_iter()
|
||||
.map(|n| build::DependencyNode {
|
||||
group: n.group,
|
||||
artifact: n.artifact,
|
||||
version: n.version,
|
||||
scope: n.scope,
|
||||
status: match n.status {
|
||||
crate::DependencyStatus::Resolved => build::DependencyStatus::Resolved,
|
||||
crate::DependencyStatus::OmittedForConflict => build::DependencyStatus::OmittedForConflict,
|
||||
crate::DependencyStatus::OmittedForDuplicate => {
|
||||
build::DependencyStatus::OmittedForDuplicate
|
||||
}
|
||||
crate::DependencyStatus::VersionManaged => build::DependencyStatus::VersionManaged,
|
||||
},
|
||||
requested_version: n.requested_version,
|
||||
parent: n.parent,
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.map_err(to_wit))
|
||||
}
|
||||
}
|
||||
|
||||
impl commit::Host for StoreData {
|
||||
fn pending_commit(&mut self) -> Fallible<Option<commit::CommitDraft>> {
|
||||
if let Err(e) = self.require(Capability::VcsRead) {
|
||||
@@ -1782,6 +1823,13 @@ impl views::Host for StoreData {
|
||||
.map_err(to_wit))
|
||||
}
|
||||
fn open_diff(&mut self, diff: views::ContentDiff, file_name: Option<String>) -> Fallible<()> {
|
||||
if let Err(e) = self.require_window() {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
let diff = crate::FileDiff::from(crate::ContentDiff::from(diff));
|
||||
Ok(self.host.open_diff(self.invocation.client.as_deref().unwrap(), diff, file_name).map_err(to_wit))
|
||||
}
|
||||
fn open_file_diff(&mut self, diff: views::FileDiff, file_name: Option<String>) -> Fallible<()> {
|
||||
if let Err(e) = self.require_window() {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
@@ -2146,6 +2194,12 @@ impl From<bindings::openidea::plugin::views::ContentDiff> for crate::ContentDiff
|
||||
}
|
||||
}
|
||||
|
||||
impl From<bindings::openidea::plugin::views::FileDiff> for crate::FileDiff {
|
||||
fn from(v: bindings::openidea::plugin::views::FileDiff) -> Self {
|
||||
Self { left: v.left, right: v.right, left_label: v.left_label, right_label: v.right_label, title: v.title }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<bindings::openidea::plugin::views::ContentTabReply> for crate::ContentTabReply {
|
||||
fn from(v: bindings::openidea::plugin::views::ContentTabReply) -> Self {
|
||||
Self {
|
||||
|
||||
@@ -91,15 +91,15 @@ fn the_sdk_carries_the_hosts_wit() {
|
||||
|
||||
#[test]
|
||||
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
|
||||
let host = v("1.9.0");
|
||||
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.0.0-rc.1"] {
|
||||
let host = v("1.10.0");
|
||||
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.0.0-rc.1"] {
|
||||
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
|
||||
}
|
||||
let newer = check_api(&v("1.10.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.10") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
let newer = check_api(&v("1.11.0"), &host).unwrap_err();
|
||||
assert!(newer.contains("1.11") && newer.contains("update OpenIDEA"), "{newer}");
|
||||
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
|
||||
let older = check_api(&v("0.2.0"), &host).unwrap_err();
|
||||
assert!(older.contains("rebuild it with the 1.9 SDK"), "{older}");
|
||||
assert!(older.contains("rebuild it with the 1.10 SDK"), "{older}");
|
||||
// 0.x: every minor is its own API.
|
||||
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
|
||||
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
75123cf60f87ec9bdd36e0b7f75efb69d000136d74c3e9da893ecd1534bdf534
|
||||
f6069ad2d31b629e4c99fbb800b3bf389ffb87ca7f24fc9cf7803fef68997ef5
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.104"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "2.13.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
|
||||
|
||||
[[package]]
|
||||
name = "equivalent"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
|
||||
|
||||
[[package]]
|
||||
name = "foldhash"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
version = "0.17.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
|
||||
dependencies = [
|
||||
"foldhash",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "id-arena"
|
||||
version = "2.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "2.14.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
|
||||
dependencies = [
|
||||
"equivalent",
|
||||
"hashbrown",
|
||||
"serde",
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "leb128fmt"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
version = "0.4.35"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
|
||||
|
||||
[[package]]
|
||||
name = "macro-string"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e7b3a5bbb2f63aaa223a671ea1bd0e7bc16bd30ce387324cf63995deaddbbd2"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
|
||||
|
||||
[[package]]
|
||||
name = "openidea-plugin"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
"wit-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "openidea-test-build-graph"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"openidea-plugin",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "prettyplease"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "1.0.28"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_core"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
|
||||
dependencies = [
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.229"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.154"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "3.0.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-encoder"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4495a6f85dd94c411c749303efcbc5defade0b0cbdbc0541495241ab917a9b5a"
|
||||
dependencies = [
|
||||
"leb128fmt",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-metadata"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c86ff6668190d9fb70372b306b4f9fe8930f0e2f57ce72e4922bf2f117900949"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"indexmap",
|
||||
"wasm-encoder",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasmparser"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "974d643b125b272607e2fff8012ea14a8328acd7621e4bafa7afb32500052b1b"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"hashbrown",
|
||||
"indexmap",
|
||||
"semver",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b85a987ab61d365382d25c7d47e26edd48941b3bf6e3fbf76eff918bc71dab06"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"wit-bindgen-rust-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-core"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "775e122e390603abfacd548027016cd0113a6e2bf2f8ce6bdd3658b013456ea8"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"heck",
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-rust"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "84e26e13b9d972026778d2ffb7985736de116026fdc8d9464f966e12df2eb240"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"heck",
|
||||
"indexmap",
|
||||
"prettyplease",
|
||||
"syn",
|
||||
"wasm-metadata",
|
||||
"wit-bindgen-core",
|
||||
"wit-component",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen-rust-macro"
|
||||
version = "0.63.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "16a008a0d6b4840677326beb4edbeb210a2f1b7d0183fb7cc33f466b90fd7fb6"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"macro-string",
|
||||
"prettyplease",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"wit-bindgen-core",
|
||||
"wit-bindgen-rust",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-component"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "078def49fdb49cab405c3006e05793b3fdaf7069126ba6b9c97d01ec8c98fe4c"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"bitflags",
|
||||
"indexmap",
|
||||
"log",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"wasm-encoder",
|
||||
"wasm-metadata",
|
||||
"wasmparser",
|
||||
"wit-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-parser"
|
||||
version = "0.262.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00f0dc051466ffe46787721fca3d088536f158ae400be044f1b1c386ba9397ad"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"hashbrown",
|
||||
"id-arena",
|
||||
"indexmap",
|
||||
"log",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"unicode-ident",
|
||||
"wasmparser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
Loaded 100 of 630 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача