Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(run): Tomcat local run configuration (#392)

l0ng-ai92b3ae508c8f
diff --git a/Cargo.lock b/Cargo.lock
index aa980437f..7c05bd413 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4462,6 +4462,7 @@ dependencies = [
"libc",
"parking_lot",
"portable-pty",
+ "quick-xml",
"serde",
"serde_json",
"specta",
diff --git a/crates/ide-build/src/gradle.rs b/crates/ide-build/src/gradle.rs
index 529ed6803..4acc986e9 100644
--- a/crates/ide-build/src/gradle.rs
+++ b/crates/ide-build/src/gradle.rs
@@ -399,6 +399,12 @@ pub fn parse_tasks(output: &str) -> Vec<(String, GradleTask)> {
out
}
+/// Static fallback until Gradle has reported its tasks.
+pub(crate) fn has_war_plugin(script: &str) -> bool {
+ let script = strip_comments(script);
+ script.split(|c: char| !c.is_alphanumeric() && c != '_').any(|word| word == "war")
+}
+
#[cfg(test)]
mod tests {
#[test]
diff --git a/crates/ide-build/src/lib.rs b/crates/ide-build/src/lib.rs
index 84783f3e8..9afb4e672 100644
--- a/crates/ide-build/src/lib.rs
+++ b/crates/ide-build/src/lib.rs
@@ -11,6 +11,7 @@ pub mod maven;
pub mod pom_edit;
mod process;
mod sync;
+pub mod web;
mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
diff --git a/crates/ide-build/src/web.rs b/crates/ide-build/src/web.rs
new file mode 100644
index 000000000..c986dee90
--- /dev/null
+++ b/crates/ide-build/src/web.rs
@@ -0,0 +1,169 @@
+//! WAR modules and build-tool-owned archive resolution (including custom output names).
+use crate::BuildModel;
+use ide_core::{IdeError, IdeResult};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::{collections::BTreeMap, fs, path::Path};
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct WebArtifact {
+ pub id: String,
+ pub name: String,
+ pub module: String,
+ pub tool: String,
+}
+
+pub fn artifacts(root: &Path, model: &BuildModel) -> Vec<WebArtifact> {
+ let mut out = Vec::new();
+ if let Some(maven) = &model.maven {
+ for p in maven.projects.iter().filter(|p| p.packaging == "war") {
+ out.push(WebArtifact {
+ id: format!("maven:{}", p.pom),
+ name: p.artifact_id.clone(),
+ module: p.dir.clone(),
+ tool: "maven".into(),
+ });
+ }
+ }
+ if let Some(gradle) = &model.gradle {
+ for p in &gradle.projects {
+ let script = p.build_file.as_ref().and_then(|f| fs::read_to_string(root.join(f)).ok()).unwrap_or_default();
+ if p.tasks.iter().any(|t| t.name == "war") || crate::gradle::has_war_plugin(&script) {
+ out.push(WebArtifact {
+ id: format!("gradle:{}", p.path),
+ name: p.name.clone(),
+ module: p.dir.clone(),
+ tool: "gradle".into(),
+ });
+ }
+ }
+ }
+ out
+}
+
+pub struct WebBuild {
+ pub command: String,
+ pub args: Vec<String>,
+ pub cwd: String,
+ pub env: BTreeMap<String, String>,
+}
+
+pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResult<WebBuild> {
+ fs::create_dir_all(cache)?;
+ let manifest = cache.join("artifact-path.txt");
+ // A failed build must never silently reuse an older archive manifest.
+ if manifest.exists() {
+ fs::remove_file(&manifest)?;
+ }
+ fs::write(cache.join("artifact-id.txt"), id)?;
+ if let Some(pom) = id.strip_prefix("maven:") {
+ let p = model
+ .maven
+ .as_ref()
+ .and_then(|m| m.projects.iter().find(|p| p.pom == pom && p.packaging == "war"))
+ .ok_or_else(|| IdeError::invalid("Choose a Maven WAR module"))?;
+ let projects = &model.maven.as_ref().unwrap().projects;
+ let top = projects
+ .iter()
+ .filter(|t| {
+ !t.aggregated && (t.dir.is_empty() || p.dir == t.dir || p.dir.starts_with(&format!("{}/", t.dir)))
+ })
+ .max_by_key(|t| t.dir.len())
+ .unwrap_or(p);
+ let mut args = top.options.clone();
+ if top.pom != p.pom {
+ let module = root
+ .join(&p.dir)
+ .strip_prefix(root.join(&top.dir))
+ .map_err(|e| IdeError::invalid(e.to_string()))?
+ .to_string_lossy()
+ .replace('\\', "/");
+ args.extend(["-pl".into(), module, "-am".into()]);
+ }
+ args.extend([
+ "-DskipTests".into(),
+ "package".into(),
+ "help:evaluate".into(),
+ "-Dexpression=project.artifact.file".into(),
+ format!("-Doutput={}", manifest.display()),
+ ]);
+ return Ok(WebBuild { command: top.command.clone(), args, cwd: top.dir.clone(), env: p.env.clone() });
+ }
+ if let Some(path) = id.strip_prefix("gradle:") {
+ let g = model.gradle.as_ref().ok_or_else(|| IdeError::invalid("Choose a Gradle WAR module"))?;
+ if !artifacts(root, model).iter().any(|a| a.id == id) {
+ return Err(IdeError::invalid("Choose a Gradle WAR module"));
+ }
+ let literal = |s: &str| format!("'{}'", s.replace('\\', "\\\\").replace('\'', "\\'"));
+ let script = cache.join("war.init.gradle");
+ fs::write(
+ &script,
+ format!(
+ r#"gradle.projectsEvaluated {{
+ def p = gradle.rootProject.project({})
+ def warTask = p.tasks.named('war')
+ p.tasks.register('openideaTomcatArtifact') {{
+ dependsOn warTask
+ doLast {{ new File({}).text = warTask.get().archiveFile.get().asFile.absolutePath }}
+ }}
+}}
+"#,
+ literal(path),
+ literal(&manifest.to_string_lossy())
+ ),
+ )?;
+ let task = format!("{}:openideaTomcatArtifact", path.trim_end_matches(':'));
+ return Ok(WebBuild {
+ command: g.command.clone(),
+ args: vec!["--init-script".into(), script.to_string_lossy().into_owned(), task],
+ cwd: g.dir.clone(),
+ env: g.env.clone(),
+ });
+ }
+ Err(IdeError::invalid("Choose a WAR artifact"))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ #[test]
+ fn maven_war_modules_use_resolved_artifact_file() {
+ let tmp = tempfile::tempdir().unwrap();
+ fs::write(tmp.path().join("pom.xml"), "<project><modelVersion>4.0.0</modelVersion><groupId>test</groupId><artifactId>web</artifactId><version>1</version><packaging>war</packaging><build><directory>custom</directory><finalName>renamed</finalName></build></project>").unwrap();
+ let model = crate::load(tmp.path(), &tmp.path().join("cache"), None);
+ let a = artifacts(tmp.path(), &model);
+ assert_eq!(a.len(), 1);
+ assert_eq!(a[0].name, "web");
+ let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base with spaces")).unwrap();
+ assert!(plan.args.contains(&"-Dexpression=project.artifact.file".into()));
+ assert!(plan.args.iter().any(|a| a.ends_with("base with spaces/artifact-path.txt")));
+ }
+ #[test]
+ fn maven_module_build_includes_reactor_dependencies() {
+ let tmp = tempfile::tempdir().unwrap();
+ fs::create_dir_all(tmp.path().join("web")).unwrap();
+ fs::write(tmp.path().join("pom.xml"), "<project><groupId>test</groupId><artifactId>parent</artifactId><version>1</version><packaging>pom</packaging><modules><module>web</module></modules></project>").unwrap();
+ fs::write(tmp.path().join("web/pom.xml"), "<project><parent><groupId>test</groupId><artifactId>parent</artifactId><version>1</version></parent><artifactId>web</artifactId><packaging>war</packaging></project>").unwrap();
+ let model = crate::load(tmp.path(), &tmp.path().join("cache"), None);
+ let plan = build(tmp.path(), &model, "maven:web/pom.xml", &tmp.path().join("base")).unwrap();
+ assert_eq!(plan.cwd, "");
+ assert_eq!(&plan.args[..3], &["-pl", "web", "-am"]);
+ }
+ #[test]
+ fn gradle_war_uses_archive_provider_and_ignores_comments() {
+ let tmp = tempfile::tempdir().unwrap();
+ fs::write(
+ tmp.path().join("build.gradle.kts"),
+ "plugins { war }\ntasks.war { archiveFileName.set(\"custom.war\") }",
+ )
+ .unwrap();
+ let model = crate::load(tmp.path(), &tmp.path().join("cache"), None);
+ let a = artifacts(tmp.path(), &model);
+ 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!(!crate::gradle::has_war_plugin("// plugins { war }"));
+ }
+}
diff --git a/crates/ide-host/src/ops/run.rs b/crates/ide-host/src/ops/run.rs
index 3dfe64fed..d9c8fadb7 100644
--- a/crates/ide-host/src/ops/run.rs
+++ b/crates/ide-host/src/ops/run.rs
@@ -40,6 +40,9 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
return Err(IdeError::invalid("run configuration has no command"));
}
// Settings › Run Targets: over SSH.
+ 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"));
+ }
if config.extras.target.as_deref().is_some_and(|t| !t.is_empty()) {
let settings = project.settings.effective();
let out = on_output.clone();
@@ -51,7 +54,7 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
let settings = project.settings.effective();
// Configurations made in the UI name bare tools (`godot`) that may live outside PATH.
let mut config = config;
- if config.kind == "gradle" {
+ if matches!(config.kind.as_str(), "gradle" | "tomcat") {
ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(&mut config), &project.root, &settings);
} else {
ide_sdk::apply::resolve_run_command(&mut config, &project.root, &settings);
@@ -59,6 +62,18 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
if config.command == ide_sdk::godot::COMMAND {
return Err(IdeError::unavailable(ide_sdk::godot::NOT_FOUND));
}
+ if config.kind == "tomcat" {
+ if host.processes.list().iter().any(|r| r.running && r.config_id == config.id) {
+ return Err(IdeError::invalid("This Tomcat configuration is already running"));
+ }
+ let (root, cache) = (project.root.clone(), project.cache_dir.clone());
+ config = tokio::task::spawn_blocking(move || {
+ ide_run::tomcat::prepare(&root, &cache, &mut config)?;
+ Ok::<_, IdeError>(config)
+ })
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))??;
+ }
let encoding = settings.console.encoding;
let options = StartOptions {
encoding: Some(encoding).filter(|e| !e.trim().is_empty()),
diff --git a/crates/ide-host/src/ops/run/commands.rs b/crates/ide-host/src/ops/run/commands.rs
index c792a44cc..fdfc21af8 100644
--- a/crates/ide-host/src/ops/run/commands.rs
+++ b/crates/ide-host/src/ops/run/commands.rs
@@ -49,8 +49,87 @@ pub async fn run_test_reports(
.map_err(|e| IdeError::internal(e.to_string()))
}
+pub async fn run_tomcat_home(host: &Host, window: &str, home: String) -> IdeResult<ide_run::tomcat::TomcatHome> {
+ let root = host.project(window)?.root.clone();
+ tokio::task::spawn_blocking(move || ide_run::tomcat::validate_home(&root.join(home)))
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))?
+}
+
+pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
+ let project = host.project(window)?;
+ tokio::task::spawn_blocking(move || {
+ let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
+ ide_build::web::artifacts(&project.root, &model)
+ })
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))
+}
+
+pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> IdeResult<Option<RunConfig>> {
+ if config.extras.params.get("deployment").is_some_and(|v| v != "artifact") {
+ return Ok(None);
+ }
+ let project = host.project(window)?;
+ tokio::task::spawn_blocking(move || {
+ let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
+ let artifacts = ide_build::web::artifacts(&project.root, &model);
+ let id = config
+ .extras
+ .params
+ .get("artifact")
+ .filter(|s| !s.is_empty())
+ .or_else(|| artifacts.first().map(|a| &a.id))
+ .ok_or_else(|| IdeError::invalid("Choose a WAR artifact"))?;
+ let plan = ide_build::web::build(
+ &project.root,
+ &model,
+ id,
+ &ide_run::tomcat::base_dir(&project.cache_dir, &config.id),
+ )?;
+ let mut env = plan.env;
+ env.extend(config.env.clone());
+ Ok(Some(RunConfig {
+ id: format!("tomcat-build:{}", config.id),
+ name: format!("Build {}", config.name),
+ kind: if id.starts_with("maven:") { "maven" } else { "gradle" }.into(),
+ command: plan.command,
+ args: plan.args,
+ cwd: Some(std::path::PathBuf::from(plan.cwd).into()),
+ env,
+ detected: false,
+ is_test: false,
+ debug_adapter: None,
+ allow_parallel: false,
+ extras: ide_run::RunExtras {
+ include_system_env: config.extras.include_system_env,
+ env_files: config.extras.env_files,
+ ..Default::default()
+ },
+ }))
+ })
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))?
+}
+
+pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mode: String) -> IdeResult<()> {
+ let project = host.project(window)?;
+ if !host.processes.list().iter().any(|r| r.running && r.config_id == config.id) {
+ return Err(IdeError::invalid("Start this Tomcat configuration before updating it"));
+ }
+ tokio::task::spawn_blocking(move || ide_run::tomcat::update(&project.root, &project.cache_dir, &config, &mode))
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))?
+}
+
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
+ d.add("run_tomcat_home", |c| async move { run_tomcat_home(&c.host, &c.window, c.arg("home")?).await });
+ d.add("run_tomcat_artifacts", |c| async move { run_tomcat_artifacts(&c.host, &c.window).await });
+ d.add("run_tomcat_build", |c| async move { run_tomcat_build(&c.host, &c.window, c.arg("config")?).await });
+ d.add("run_tomcat_update", |c| async move {
+ run_tomcat_update(&c.host, &c.window, c.arg("config")?, c.arg("mode")?).await
+ });
d.add("run_templates", |c| async move { run_templates(&c.host, &c.window) });
d.add("run_save_templates", |c| async move { run_save_templates(&c.host, &c.window, c.arg("templates")?) });
d.add("run_system_env", |c| async move { Ok(run_system_env(&c.host, &c.window)) });
diff --git a/crates/ide-run/Cargo.toml b/crates/ide-run/Cargo.toml
index bacdf07f0..23df66031 100644
--- a/crates/ide-run/Cargo.toml
+++ b/crates/ide-run/Cargo.toml
@@ -18,6 +18,7 @@ portable-pty.workspace = true
parking_lot.workspace = true
tracing.workspace = true
zip.workspace = true
+quick-xml = "0.42"
[target.'cfg(unix)'.dependencies]
libc = "0.2"
diff --git a/crates/ide-run/src/lib.rs b/crates/ide-run/src/lib.rs
index 31b6c8f3e..97eb4afd0 100644
--- a/crates/ide-run/src/lib.rs
+++ b/crates/ide-run/src/lib.rs
@@ -8,6 +8,7 @@ pub mod java_cmdline;
pub mod junit;
mod process;
pub mod python_path;
+pub mod tomcat;
mod utf8;
pub mod which;
pub mod wrap;
diff --git a/crates/ide-run/src/tomcat.rs b/crates/ide-run/src/tomcat.rs
new file mode 100644
index 000000000..7410dd187
--- /dev/null
+++ b/crates/ide-run/src/tomcat.rs
@@ -0,0 +1,474 @@
+//! Isolated local Tomcat installations and deployments. Never writes to CATALINA_HOME.
+use crate::RunConfig;
+use ide_core::{IdeError, IdeResult};
+use quick_xml::{
+ Reader, Writer,
+ events::{BytesStart, Event},
+};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::{
+ fs,
+ io::Read,
+ net::TcpListener,
+ path::{Path, PathBuf},
+};
+
+fn invalid(e: impl std::fmt::Display) -> IdeError {
+ IdeError::invalid(e.to_string())
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct TomcatHome {
+ pub version: String,
+}
+
+pub fn validate_home(home: &Path) -> IdeResult<TomcatHome> {
+ if !(home.join("bin/catalina.sh").is_file() || home.join("bin/catalina.bat").is_file())
+ || !home.join("lib/catalina.jar").is_file()
+ {
+ return Err(invalid("Tomcat home must contain bin/catalina.sh or bin/catalina.bat and lib/catalina.jar"));
+ }
+ let mut jar = zip::ZipArchive::new(fs::File::open(home.join("lib/catalina.jar"))?).map_err(invalid)?;
+ let mut properties = String::new();
+ jar.by_name("org/apache/catalina/util/ServerInfo.properties").map_err(invalid)?.read_to_string(&mut properties)?;
+ let version =
+ properties.lines().find_map(|l| l.strip_prefix("server.info=")).unwrap_or("Apache Tomcat").trim().to_owned();
+ Ok(TomcatHome { version })
+}
+
+pub fn base_dir(cache: &Path, id: &str) -> PathBuf {
+ // Stable and collision-free for configuration IDs, including Windows path characters.
+ let key: String = id.as_bytes().iter().map(|b| format!("{b:02x}")).collect();
+ cache.join("tomcat").join(key)
+}
+
+pub fn free_port() -> IdeResult<u16> {
+ Ok(TcpListener::bind(("127.0.0.1", 0))?.local_addr()?.port())
+}
+
+pub fn context_name(context: &str) -> IdeResult<String> {
+ if context.is_empty() || context == "/" {
+ return Ok("ROOT".into());
+ }
+ if !context.starts_with('/')
+ || context.ends_with('/')
+ || context[1..].split('/').any(|p| {
+ p.is_empty() || p == "." || p == ".." || !p.chars().all(|c| c.is_alphanumeric() || "-_".contains(c))
+ })
+ {
+ return Err(invalid("Context path must start with / and contain only letters, digits, /, - or _"));
+ }
+ Ok(context[1..].replace('/', "#"))
+}
+
+fn escape(text: &str) -> String {
+ quick_xml::escape::escape(text).into_owned()
+}
+
+pub fn context_xml(doc_base: &Path, reload: bool) -> String {
+ format!("<Context docBase=\"{}\" reloadable=\"{reload}\" />\n", escape(&doc_base.to_string_lossy()))
+}
+
+pub fn patch_server_xml(xml: &str, http: u16, shutdown: u16, secret: &str) -> IdeResult<String> {
+ let mut reader = Reader::from_str(xml);
+ let mut writer = Writer::new(Vec::new());
+ let mut http_found = false;
+ loop {
+ let event = reader.read_event().map_err(invalid)?;
+ if matches!(event, Event::Eof) {
+ break;
+ }
+ let event = match event {
+ Event::Start(ref tag) | Event::Empty(ref tag) => {
+ let name = tag.name().as_ref().to_owned();
+ let mut attrs: Vec<(String, String)> = tag
+ .attributes()
+ .map(|a| {
+ let a = a.map_err(invalid)?;
+ Ok((
+ a.key.as_ref().to_owned(),
+ a.normalized_value(quick_xml::XmlVersion::Implicit1_0).map_err(invalid)?.into_owned(),
+ ))
+ })
+ .collect::<IdeResult<_>>()?;
+ let mut set = |key: &str, value: String| {
+ attrs.retain(|(k, _)| k != key);
+ attrs.push((key.into(), value));
+ };
+ match name.as_str() {
+ "Server" => {
+ set("port", shutdown.to_string());
+ set("address", "127.0.0.1".into());
+ set("shutdown", secret.into());
+ }
+ "Connector" => {
+ let protocol = tag
+ .try_get_attribute("protocol")
+ .map_err(invalid)?
+ .map(|a| a.value.into_owned())
+ .unwrap_or_default();
+ let is_http = !http_found
+ && (protocol.is_empty() || protocol.contains("HTTP") || protocol.contains("Http"));
+ set("port", if is_http { http } else { free_port()? }.to_string());
+ if is_http {
+ http_found = true;
+ }
+ }
+ "Engine" => set("name", "Catalina".into()),
+ "Host" => {
+ set("name", "localhost".into());
+ set("appBase", "webapps".into());
+ set("autoDeploy", "true".into());
+ set("deployOnStartup", "true".into());
+ }
+ _ => {}
+ }
+ let mut new = BytesStart::new(name);
+ for (k, v) in &attrs {
+ new.push_attribute((k.as_str(), v.as_str()));
+ }
+ if matches!(event, Event::Empty(_)) { Event::Empty(new) } else { Event::Start(new) }
+ }
+ e => e.into_owned(),
+ };
+ writer.write_event(event).map_err(invalid)?;
+ }
+ if !http_found {
+ return Err(invalid("Tomcat server.xml has no HTTP connector"));
+ }
+ String::from_utf8(writer.into_inner()).map_err(invalid)
+}
+
+fn copy_tree(from: &Path, to: &Path) -> IdeResult<()> {
+ fs::create_dir_all(to)?;
+ for entry in fs::read_dir(from)? {
+ let entry = entry?;
+ let target = to.join(entry.file_name());
+ if entry.file_type()?.is_dir() {
+ copy_tree(&entry.path(), &target)?;
+ } else {
+ fs::copy(entry.path(), target)?;
+ }
+ }
+ Ok(())
+}
+
+/// Synchronize an archive into a private exploded deployment, preserving unchanged class timestamps.
+pub fn explode(war: &Path, destination: &Path, resources_only: bool) -> IdeResult<()> {
+ let mut zip = zip::ZipArchive::new(fs::File::open(war)?).map_err(invalid)?;
+ fs::create_dir_all(destination)?;
+ let mut expected = std::collections::HashSet::new();
+ for i in 0..zip.len() {
+ let mut entry = zip.by_index(i).map_err(invalid)?;
+ let path = entry.enclosed_name().ok_or_else(|| invalid("WAR contains an invalid path"))?;
+ expected.insert(path.clone());
+ if entry.is_dir() {
+ continue;
+ }
+ if resources_only && (path.extension().is_some_and(|e| e == "class") || path.starts_with("WEB-INF/lib")) {
+ continue;
+ }
+ let target = destination.join(&path);
+ let mut bytes = Vec::new();
+ entry.read_to_end(&mut bytes)?;
+ if fs::read(&target).ok().as_deref() != Some(&bytes) {
+ fs::create_dir_all(target.parent().unwrap())?;
+ fs::write(target, bytes)?;
+ }
+ }
+ fn remove_stale(
+ root: &Path,
+ dir: &Path,
+ expected: &std::collections::HashSet<PathBuf>,
+ resources: bool,
+ ) -> IdeResult<()> {
+ for entry in fs::read_dir(dir)? {
+ let entry = entry?;
+ let path = entry.path();
+ if entry.file_type()?.is_dir() {
+ remove_stale(root, &path, expected, resources)?;
+ } else {
+ let rel = path.strip_prefix(root).map_err(invalid)?;
+ if !expected.contains(rel)
+ && !(resources && (rel.extension().is_some_and(|e| e == "class") || rel.starts_with("WEB-INF/lib")))
+ {
+ fs::remove_file(path)?;
+ }
+ }
+ }
+ Ok(())
+ }
+ remove_stale(destination, destination, &expected, resources_only)
+}
+
+pub fn deployment(root: &Path, base: &Path, config: &RunConfig, resources_only: bool) -> IdeResult<PathBuf> {
+ let p = &config.extras.params;
+ match p.get("deployment").map(String::as_str).unwrap_or("artifact") {
+ "artifact" => {
+ if let Some(id) = p.get("artifact").filter(|s| !s.is_empty())
+ && fs::read_to_string(base.join("artifact-id.txt")).ok().as_ref() != Some(id)
+ {
+ return Err(invalid("Build the selected WAR artifact before launching Tomcat"));
+ }
+ let war = fs::read_to_string(base.join("artifact-path.txt"))
+ .map_err(|_| invalid("Build the WAR artifact before launching Tomcat"))?;
+ let war = PathBuf::from(war.trim());
+ if !war.is_file() || !war.extension().is_some_and(|e| e.eq_ignore_ascii_case("war")) {
+ return Err(invalid("The built WAR artifact does not exist"));
+ }
+ let dest = base.join("deployment");
+ explode(&war, &dest, resources_only)?;
+ Ok(dest)
+ }
+ kind @ ("war" | "directory") => {
+ let value = p
+ .get("deploymentPath")
+ .filter(|v| !v.trim().is_empty())
+ .ok_or_else(|| invalid("Choose a WAR file or exploded directory"))?;
+ let path = root.join(value).canonicalize()?;
+ if (kind == "war" && (!path.is_file() || !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("war"))))
+ || (kind == "directory" && !path.is_dir())
+ {
+ return Err(invalid("Invalid Tomcat deployment"));
+ }
+ Ok(path)
+ }
+ _ => Err(invalid("Unknown Tomcat deployment type")),
+ }
+}
+
+pub fn effective_context(config: &RunConfig, doc: &Path) -> String {
+ config.extras.params.get("contextPath").filter(|s| !s.is_empty()).cloned().unwrap_or_else(|| {
+ let name = config
+ .extras
+ .params
+ .get("artifactName")
+ .cloned()
+ .unwrap_or_else(|| doc.file_stem().unwrap_or_default().to_string_lossy().into_owned());
+ if name == "ROOT" { "/".into() } else { format!("/{name}") }
+ })
+}
+
+/// Platform-neutral plan; Windows uses the process manager's raw cmd quoting for batch scripts.
+pub fn script_command(home: &Path, windows: bool, verb: &str) -> (String, Vec<String>) {
+ if windows {
+ (format!("\"{}\" {verb}", home.join("bin/catalina.bat").display()), vec![])
+ } else {
+ ("sh".into(), vec![home.join("bin/catalina.sh").to_string_lossy().into_owned(), verb.into()])
+ }
+}
+
+pub fn prepare(root: &Path, cache: &Path, config: &mut RunConfig) -> IdeResult<()> {
+ let home = root
+ .join(config.extras.params.get("tomcatHome").ok_or_else(|| invalid("Choose a Tomcat installation directory"))?)
+ .canonicalize()?;
+ validate_home(&home)?;
+ let base = base_dir(cache, &config.id);
+ fs::create_dir_all(&base)?;
+ let base = base.canonicalize()?;
+ let doc = deployment(root, &base, config, false)?;
+ let context = effective_context(config, &doc);
+ let context = context_name(&context)?;
+ let port: u16 =
+ config.extras.params.get("httpPort").map(String::as_str).unwrap_or("8080").parse().map_err(invalid)?;
+ if port == 0 {
+ return Err(invalid("HTTP port must be between 1 and 65535"));
+ }
+ let shutdown = free_port()?;
+ let secret = format!(
+ "OPENIDEA_{}_{}",
+ std::process::id(),
+ std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_err(invalid)?.as_nanos()
+ );
+ // Refresh only the IDE-owned configuration, leaving logs and deployed artifacts available.
+ if base.join("conf").exists() {
+ fs::remove_dir_all(base.join("conf"))?;
+ }
+ copy_tree(&home.join("conf"), &base.join("conf"))?;
+ let contexts = base.join("conf/Catalina/localhost");
+ if contexts.exists() {
+ fs::remove_dir_all(&contexts)?;
+ }
+ for dir in ["logs", "temp", "work", "webapps", "conf/Catalina/localhost"] {
+ fs::create_dir_all(base.join(dir))?;
+ }
+ let server = patch_server_xml(&fs::read_to_string(home.join("conf/server.xml"))?, port, shutdown, &secret)?;
+ fs::write(base.join("conf/server.xml"), server)?;
+ let debug = config.extras.params.get("tomcatDebug").is_some_and(|v| v == "true");
+ fs::write(contexts.join(format!("{context}.xml")), context_xml(&doc, !debug))?;
+ config.env.insert("CATALINA_HOME".into(), home.to_string_lossy().into_owned());
+ config.env.insert("CATALINA_BASE".into(), base.to_string_lossy().into_owned());
+ if let Some(jre) = config.extras.params.get("jre").filter(|s| !s.trim().is_empty()) {
+ let jre = root.join(jre).canonicalize()?;
+ config.env.insert("JAVA_HOME".into(), jre.to_string_lossy().into_owned());
+ config.env.insert("JRE_HOME".into(), jre.to_string_lossy().into_owned());
+ } else if let Some(java) = config.env.get("JAVA_HOME").cloned() {
+ config.env.insert("JRE_HOME".into(), java);
+ }
+ let vm = config.extras.params.get("vmOptions").cloned().unwrap_or_default();
+ let jmx = free_port()?;
+ let mut opts = config.env.get("CATALINA_OPTS").cloned().unwrap_or_default();
+ opts.push_str(&format!(" {vm} -Dcom.sun.management.jmxremote.port={jmx} -Dcom.sun.management.jmxremote.rmi.port={jmx} -Dcom.sun.management.jmxremote.host=127.0.0.1 -Djava.rmi.server.hostname=127.0.0.1 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false"));
+ if debug {
+ opts.push_str(" -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:0");
+ }
+ config.env.insert("CATALINA_OPTS".into(), opts);
+ (config.command, config.args) = script_command(&home, cfg!(windows), "run");
+ config.extras.stop_command = Some(if cfg!(windows) {
+ script_command(&home, true, "stop").0
+ } else {
+ format!("sh '{}' stop", home.join("bin/catalina.sh").to_string_lossy().replace('\'', "'\\''"))
+ });
+ config.extras.emulate_terminal = false;
+ Ok(())
+}
+
+pub fn update(root: &Path, cache: &Path, config: &RunConfig, mode: &str) -> IdeResult<()> {
+ if !matches!(mode, "resources" | "classes" | "redeploy") {
+ return Err(invalid("Unknown Tomcat update operation"));
+ }
+ let base = base_dir(cache, &config.id);
+ let doc = deployment(root, &base, config, mode == "resources")?;
+ let context = context_name(&effective_context(config, &doc))?;
+ let file = base.join("conf/Catalina/localhost").join(format!("{context}.xml"));
+ if !file.is_file() {
+ return Err(invalid("Start this Tomcat configuration before updating it"));
+ }
+ if mode == "redeploy" {
+ let content = fs::read(&file)?;
+ fs::write(file, content)?;
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::io::Write;
+ fn archive(path: &Path, entries: &[(&str, &str)]) {
+ fs::create_dir_all(path.parent().unwrap()).unwrap();
+ let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+ for (name, text) in entries {
+ zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
+ zip.write_all(text.as_bytes()).unwrap();
+ }
+ zip.finish().unwrap();
+ }
+ fn config() -> RunConfig {
+ RunConfig {
+ id: "local:demo".into(),
+ name: "Tomcat".into(),
+ kind: "tomcat".into(),
+ command: "catalina".into(),
+ args: vec!["run".into()],
+ cwd: None,
+ env: Default::default(),
+ detected: false,
+ is_test: false,
+ debug_adapter: Some("java-debug".into()),
+ allow_parallel: false,
+ extras: Default::default(),
+ }
+ }
+ #[test]
+ fn validates_home_and_reads_version() {
+ let tmp = tempfile::tempdir().unwrap();
+ assert!(validate_home(tmp.path()).is_err());
+ fs::create_dir_all(tmp.path().join("bin")).unwrap();
+ fs::write(tmp.path().join("bin/catalina.bat"), "").unwrap();
+ archive(
+ &tmp.path().join("lib/catalina.jar"),
+ &[("org/apache/catalina/util/ServerInfo.properties", "server.info=Apache Tomcat/10.1.61\n")],
+ );
+ assert_eq!(validate_home(tmp.path()).unwrap().version, "Apache Tomcat/10.1.61");
+ }
+ #[test]
+ fn patches_ports_without_changing_comments_and_escapes_context() {
+ let xml = "<Server port='8005' shutdown='SHUTDOWN'><!-- <Connector port=\"8080\"/> --><Service><Connector port='8080' protocol='HTTP/1.1'/><Connector port='8009' protocol='AJP/1.3'/><Engine name='Catalina'><Host name='localhost'/></Engine></Service></Server>";
+ let patched = patch_server_xml(xml, 18080, 18005, "SECRET").unwrap();
+ assert!(patched.contains("port=\"18080\""));
+ assert!(patched.contains("port=\"18005\""));
+ assert!(!patched.contains("port=\"8009\""));
+ assert!(patched.contains("<!-- <Connector port=\"8080\"/> -->"));
+ assert_eq!(context_name("/").unwrap(), "ROOT");
+ assert_eq!(context_name("/a/b").unwrap(), "a#b");
+ for path in ["../escape", "/../escape", "/x#y", "/a//b", "/a/"] {
+ assert!(context_name(path).is_err());
+ }
+ assert!(context_xml(Path::new("/tmp/a & b/\"web\""), false).contains("a &amp; b/&quot;web&quot;"));
+ }
+ #[test]
+ fn constructs_platform_commands_without_splitting_paths() {
+ let home = Path::new("/some path/tomcat");
+ assert_eq!(
+ script_command(home, false, "run"),
+ ("sh".into(), vec!["/some path/tomcat/bin/catalina.sh".into(), "run".into()])
+ );
+ let (command, args) = script_command(home, true, "run");
+ assert_eq!(command, "\"/some path/tomcat/bin/catalina.bat\" run");
+ assert!(args.is_empty());
+ }
+ #[test]
+ fn resolves_manual_deployments_and_synchronizes_war_resources() {
+ let tmp = tempfile::tempdir().unwrap();
+ let war = tmp.path().join("web app.war");
+ archive(&war, &[("index.html", "old"), ("WEB-INF/classes/App.class", "class1"), ("removed.txt", "delete")]);
+ let base = tmp.path().join("cache");
+ fs::create_dir_all(&base).unwrap();
+ fs::write(base.join("artifact-path.txt"), war.to_string_lossy().as_bytes()).unwrap();
+ let mut c = config();
+ let dest = deployment(tmp.path(), &base, &c, false).unwrap();
+ archive(&war, &[("index.html", "new"), ("WEB-INF/classes/App.class", "class2")]);
+ deployment(tmp.path(), &base, &c, true).unwrap();
+ assert_eq!(fs::read_to_string(dest.join("index.html")).unwrap(), "new");
+ assert_eq!(fs::read_to_string(dest.join("WEB-INF/classes/App.class")).unwrap(), "class1");
+ assert!(!dest.join("removed.txt").exists());
+ deployment(tmp.path(), &base, &c, false).unwrap();
+ assert_eq!(fs::read_to_string(dest.join("WEB-INF/classes/App.class")).unwrap(), "class2");
+ c.extras.params.insert("deployment".into(), "war".into());
+ c.extras.params.insert("deploymentPath".into(), "web app.war".into());
+ assert_eq!(deployment(tmp.path(), &base, &c, false).unwrap(), war.canonicalize().unwrap());
+ fs::create_dir_all(tmp.path().join("WebContent")).unwrap();
+ c.extras.params.insert("deployment".into(), "directory".into());
+ c.extras.params.insert("deploymentPath".into(), "WebContent".into());
+ assert!(deployment(tmp.path(), &base, &c, false).unwrap().ends_with("WebContent"));
+ }
+ #[test]
+ fn prepares_isolated_base_and_jdwp_only_for_run() {
+ let tmp = tempfile::tempdir().unwrap();
+ let home = tmp.path().join("Tomcat Home");
+ fs::create_dir_all(home.join("bin")).unwrap();
+ fs::create_dir_all(home.join("conf")).unwrap();
+ fs::create_dir_all(tmp.path().join("WebRoot")).unwrap();
+ fs::write(home.join("bin/catalina.sh"), "").unwrap();
+ archive(
+ &home.join("lib/catalina.jar"),
+ &[("org/apache/catalina/util/ServerInfo.properties", "server.info=Apache Tomcat/10.1")],
+ );
+ let server = "<Server port='8005'><Service><Connector port='8080'/><Engine name='Catalina'><Host name='localhost'/></Engine></Service></Server>";
+ fs::write(home.join("conf/server.xml"), server).unwrap();
+ let mut c = config();
+ for (k, v) in [
+ ("tomcatHome", "Tomcat Home"),
+ ("deployment", "directory"),
+ ("deploymentPath", "WebRoot"),
+ ("contextPath", "/app"),
+ ("tomcatDebug", "true"),
+ ("vmOptions", "-Xmx256m"),
+ ] {
+ c.extras.params.insert(k.into(), v.into());
+ }
+ c.env.insert("JAVA_HOME".into(), "/jdk with spaces".into());
+ prepare(tmp.path(), &tmp.path().join("cache"), &mut c).unwrap();
+ assert_eq!(fs::read_to_string(home.join("conf/server.xml")).unwrap(), server);
+ let base = PathBuf::from(&c.env["CATALINA_BASE"]);
+ assert!(base.join("conf/Catalina/localhost/app.xml").is_file());
+ assert!(c.env["CATALINA_OPTS"].contains("suspend=n,address=127.0.0.1:0"));
+ assert!(c.env["CATALINA_OPTS"].contains("-Xmx256m"));
+ assert!(!c.env.get("JAVA_OPTS").is_some_and(|s| s.contains("jdwp")));
+ assert_eq!(c.env["JRE_HOME"], "/jdk with spaces");
+ assert!(c.extras.stop_command.unwrap().contains("catalina.sh' stop"));
+ }
+}
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index 527e1924a..5e0d685bd 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -651,7 +651,7 @@ pub fn apply_to_run_configs(configs: &mut [RunConfig], root: &Path, s: &Settings
c.env.entry(key).or_insert(value);
}
}
- "maven" => {
+ "maven" | "tomcat" => {
if let Some(jdk) = &jdk {
c.env.entry("JAVA_HOME".into()).or_insert_with(|| jdk.home.to_string_lossy().into_owned());
}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 71c00ca72..8085a112f 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -284,6 +284,10 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
run::run_close_stdin,
run::run_resize,
run::run_gradle_jvm_args_script,
+ run::run_tomcat_home,
+ run::run_tomcat_artifacts,
+ run::run_tomcat_build,
+ run::run_tomcat_update,
run::run_test_reports,
build::build_model,
build::build_sync,
diff --git a/src-tauri/src/commands/run.rs b/src-tauri/src/commands/run.rs
index 09701bb7a..fcfe8efa8 100644
--- a/src-tauri/src/commands/run.rs
+++ b/src-tauri/src/commands/run.rs
@@ -117,3 +117,40 @@ pub async fn run_test_reports(
) -> IdeResult<Vec<ide_run::junit::TestCaseReport>> {
ide_host::ops::run::run_test_reports(&state.host, window.label(), module, since_ms).await
}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn run_tomcat_home(
+ window: Window,
+ state: State<'_, AppState>,
+ home: String,
+) -> IdeResult<ide_run::tomcat::TomcatHome> {
+ ide_host::ops::run::run_tomcat_home(&state.host, window.label(), home).await
+}
+#[tauri::command]
+#[specta::specta]
+pub async fn run_tomcat_artifacts(
+ window: Window,
+ state: State<'_, AppState>,
+) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
+ ide_host::ops::run::run_tomcat_artifacts(&state.host, window.label()).await
+}
+#[tauri::command]
+#[specta::specta]
+pub async fn run_tomcat_build(
+ window: Window,
+ state: State<'_, AppState>,
+ config: RunConfig,
+) -> IdeResult<Option<RunConfig>> {
+ ide_host::ops::run::run_tomcat_build(&state.host, window.label(), config).await
+}
+#[tauri::command]
+#[specta::specta]
+pub async fn run_tomcat_update(
+ window: Window,
+ state: State<'_, AppState>,
+ config: RunConfig,
+ mode: String,
+) -> IdeResult<()> {
+ ide_host::ops::run::run_tomcat_update(&state.host, window.label(), config, mode).await
+}
diff --git a/src-tauri/src/menu.rs b/src-tauri/src/menu.rs
index d9754a0dc..3e4d00ecb 100644
--- a/src-tauri/src/menu.rs
+++ b/src-tauri/src/menu.rs
@@ -571,6 +571,7 @@ pub fn spec(os: Os) -> Vec<Entry> {
act("run.chooseDebugConfig", "Debug…"),
act("runAnything.show", "Run Anything…"),
act("run.editConfigs", "Edit Configurations…"),
+ act("run.updateApplication", "Update Application"),
act("debug.attachToProcess", "Attach to Process…"),
SEP,
act("debug.resume", "Resume Program"),
diff --git a/src/bindings.ts b/src/bindings.ts
index c00b882fa..891b7efc2 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -544,6 +544,28 @@ export const commands = {
runResize: (id: RunId, cols: number, rows: number) => typedError<null, IdeError>(__TAURI_INVOKE("run_resize", { id, cols, rows })),
/** Writes the Gradle init script adding `jvm_args` to the JVMs the build forks; returns its path. */
runGradleJvmArgsScript: (jvmArgs: string[]) => typedError<string, IdeError>(__TAURI_INVOKE("run_gradle_jvm_args_script", { jvmArgs })),
+ runTomcatHome: (home: string) => typedError<TomcatHome, IdeError>(__TAURI_INVOKE("run_tomcat_home", { home })),
+ runTomcatArtifacts: () => typedError<WebArtifact[], IdeError>(__TAURI_INVOKE("run_tomcat_artifacts")),
+ runTomcatBuild: (config: RunConfig_Deserialize) => typedError<({
+ /** Stable id, e.g. `npm:dev`, `cargo:run:app`, or a uuid for user-defined. */
+ id: string,
+ name: string,
+ /** `npm` | `cargo` | `gradle` | `maven` | `go` | `python` | `pytest` | `make` | `shell` … */
+ kind: string,
+ command: string,
+ args: string[],
+ cwd: IpcPath | null,
+ env: { [key in string]: string },
+ /** Detected configs are regenerated; user configs persist in `.openidea/run.toml`. */
+ detected: boolean,
+ /** Test runner configs render results in the test tree. */
+ isTest: boolean,
+ /** DAP adapter that can debug this config, if any. */
+ debugAdapter: string | null,
+ /** "Allow multiple instances": Run on a running config starts another one instead of restarting it. */
+ allowParallel?: boolean,
+}) & (RunExtras_Serialize) | null, IdeError>(__TAURI_INVOKE("run_tomcat_build", { config })),
+ runTomcatUpdate: (config: RunConfig_Deserialize, mode: string) => typedError<null, IdeError>(__TAURI_INVOKE("run_tomcat_update", { config, mode })),
/**
* Results from the JUnit XML reports (Surefire, Failsafe, Gradle) of the module at
* `module` (relative to the project root) written since `since_ms` (Unix epoch, ms).
@@ -5864,6 +5886,10 @@ export type ThreadInfo = {
name: string,
};
+export type TomcatHome = {
+ version: string,
+};
+
/** UI-facing state of one tool. */
export type ToolInfo = {
/** Server / adapter name from `languages/*.toml`. */
@@ -6047,6 +6073,13 @@ export type Visibility = "public" | "protected" |
/** Package / module / assembly scope (Java default, `internal`, `pub(crate)`, Go unexported). */
"package" | "private";
+export type WebArtifact = {
+ id: string,
+ name: string,
+ module: string,
+ tool: string,
+};
+
/**
* A web reference no language server resolves and where it points: `class="card"` →
* `.card` selectors, `id` → `#id` selectors, `href="#top"` → the element, `var(--x)` →
diff --git a/src/features/debugger/__tests__/hotswap.test.ts b/src/features/debugger/__tests__/hotswap.test.ts
index a8ffc840b..ace2fc1b3 100644
--- a/src/features/debugger/__tests__/hotswap.test.ts
+++ b/src/features/debugger/__tests__/hotswap.test.ts
@@ -87,6 +87,16 @@ describe("HotSwap", () => {
expect(notes.at(-1)).toMatchObject({ level: "info", title: "2 classes reloaded" });
});
+ it("limits a configuration update to that configuration's debug session", async () => {
+ const one = { ...session(1, true), runConfig: { id: "tomcat:one" } as NonNullable<DebugSession["runConfig"]> };
+ const two = { ...session(2, true), runConfig: { id: "tomcat:two" } as NonNullable<DebugSession["runConfig"]> };
+ useDebug.setState({ sessions: { 1: one, 2: two } });
+ await reloadChangedClasses(false, "tomcat:two");
+ expect(ipc.javaBuildWorkspace).not.toHaveBeenCalled();
+ expect(ipc.debugRedefineClasses).toHaveBeenCalledTimes(1);
+ expect(ipc.debugRedefineClasses).toHaveBeenCalledWith(2);
+ });
+
it("does not reload after a failed build", async () => {
ipc.javaBuildWorkspace.mockImplementationOnce(() => ipc.ok("failed"));
await reloadChangedClasses();
diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.ts
index d40740b5f..939101f0a 100644
--- a/src/features/debugger/actions.ts
+++ b/src/features/debugger/actions.ts
@@ -341,7 +341,13 @@ export function registerDebugActions(): () => void {
icon: "refresh",
keywords: ["hotswap", "hot swap", "hot code replace"],
when: "debugCanHotSwap",
- run: () => reloadChangedClasses(),
+ run: ({ arg }) =>
+ reloadChangedClasses(
+ true,
+ typeof arg === "object" && arg !== null && "configId" in arg && typeof arg.configId === "string"
+ ? arg.configId
+ : undefined,
+ ),
},
{
id: "debug.rerun",
diff --git a/src/features/debugger/hotswap.ts b/src/features/debugger/hotswap.ts
index d13abdb0c..a4825af1a 100644
--- a/src/features/debugger/hotswap.ts
+++ b/src/features/debugger/hotswap.ts
@@ -33,8 +33,8 @@ export function hotSwapMessage(
}
/** Compiles (unless `build` is false) and reloads changed classes into every Java debug session. */
-export async function reloadChangedClasses(build = true): Promise<void> {
- const sessions = hotSwapSessions();
+export async function reloadChangedClasses(build = true, configId?: string): Promise<void> {
+ const sessions = hotSwapSessions().filter((s) => !configId || s.runConfig?.id === configId);
if (!sessions.length || !isTauri()) {
notifications().notify({ group: "run", level: "info", key: KEY, title: "No debug session can reload classes" });
return;
diff --git a/src/features/run/ConfigForm.tsx b/src/features/run/ConfigForm.tsx
index fea940889..6933e0253 100644
--- a/src/features/run/ConfigForm.tsx
+++ b/src/features/run/ConfigForm.tsx
@@ -25,6 +25,7 @@ import {
import { EnvDialog } from "./EnvDialog";
import { withTarget } from "./remote";
import { COMPOUND, formParams, terminalApplies, withParams } from "./types";
+import { TomcatSettings } from "./TomcatSettings";
import styles from "./Run.module.css";
/**
@@ -331,7 +332,7 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
</Field>
)}
<div className={styles.formSection}>
- <span className={styles.formSectionTitle}>{tx(type?.label ?? kindLabel(config.kind))}</span>
+ <span className={styles.formSectionTitle}>{tx(kindLabel(config.kind))}</span>
<button
ref={modifyRef}
type="button"
@@ -352,6 +353,8 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
/>
</div>
+ {config.kind === "tomcat" && <TomcatSettings config={config} onChange={onChange} />}
+
{compound ? (
template ? null : (
<CompoundMembers
diff --git a/src/features/run/RunView.tsx b/src/features/run/RunView.tsx
index acc964e22..9170bca96 100644
--- a/src/features/run/RunView.tsx
+++ b/src/features/run/RunView.tsx
@@ -29,6 +29,7 @@ import {
} from "./store";
import { TestTreeView, formatDuration } from "./TestTreeView";
import { StackTracePanel, closeStackTrace, useStackTraces, type StackTraceTab } from "./stackTrace";
+import { showTomcatUpdate } from "./tomcatUpdate";
import styles from "./Run.module.css";
import { tx } from "@/platform/i18n";
@@ -140,6 +141,15 @@ export function SessionPanel({ session }: { session: RunSession }) {
disabled={!running}
onClick={() => void stopSession(session.id)}
/>
+ {session.config.kind === "tomcat" && (
+ <IconButton
+ icon="refresh"
+ title="Update Application"
+ shortcut={shortcutLabel("run.updateApplication")}
+ disabled={!running}
+ onClick={() => showTomcatUpdate(session.id)}
+ />
+ )}
<div className={styles.toolbarSep} />
{!rt.terminal && (
<>
diff --git a/src/features/run/TomcatSettings.tsx b/src/features/run/TomcatSettings.tsx
new file mode 100644
index 000000000..92c02c326
--- /dev/null
+++ b/src/features/run/TomcatSettings.tsx
@@ -0,0 +1,103 @@
+import { useEffect, useRef, useState } from "react";
+import { call, commands, type RunConfig, type WebArtifact } from "@/platform/ipc";
+import { Select, T } from "@/ui";
+import { useTx } from "@/platform/i18n";
+import styles from "./Run.module.css";
+
+/** Asynchronous installation validation and project artifact discovery in the configuration editor. */
+export function TomcatSettings({ config, onChange }: { config: RunConfig; onChange: (config: RunConfig) => void }) {
+ const tx = useTx();
+ const [artifacts, setArtifacts] = useState<WebArtifact[]>([]);
+ const [status, setStatus] = useState("");
+ const [error, setError] = useState("");
+ const latest = useRef({ config, onChange });
+ useEffect(() => {
+ latest.current = { config, onChange };
+ }, [config, onChange]);
+ const select = (artifact: WebArtifact) => {
+ const { config, onChange } = latest.current;
+ onChange({
+ ...config,
+ cwd: artifact.module || null,
+ params: {
+ ...config.params,
+ artifact: artifact.id,
+ artifactName: artifact.name,
+ contextPath: config.params?.contextPath || `/${artifact.name}`,
+ },
+ });
+ };
+ useEffect(() => {
+ let live = true;
+ void call(commands.runTomcatArtifacts())
+ .then((items) => {
+ if (!live) return;
+ setArtifacts(items);
+ if (!latest.current.config.params?.artifact && items[0]) select(items[0]);
+ })
+ .catch((e) => {
+ if (live) setError(String(e));
+ });
+ return () => {
+ live = false;
+ };
+ }, []);
+ const home = config.params?.tomcatHome ?? "";
+ useEffect(() => {
+ let live = true;
+ const timer = setTimeout(() => {
+ setStatus("");
+ setError("");
+ if (home.trim())
+ void call(commands.runTomcatHome(home))
+ .then((info) => {
+ if (live) setStatus(info.version);
+ })
+ .catch(() => {
+ if (live) setError("Invalid Tomcat installation: check bin/catalina and lib/catalina.jar");
+ });
+ }, 250);
+ return () => {
+ live = false;
+ clearTimeout(timer);
+ };
+ }, [home]);
+ return (
+ <>
+ {status && (
+ <div className={styles.notice} role="status">
+ {status}
+ </div>
+ )}
+ {error && (
+ <div className={styles.fieldError} role="alert">
+ {tx(error)}
+ </div>
+ )}
+ {(config.params?.deployment ?? "artifact") === "artifact" && (
+ <div className={styles.field}>
+ <span className={styles.fieldLabel}>
+ <T>WAR artifact</T>
+ </span>
+ <div className={styles.fieldControl}>
+ <Select
+ aria-label="WAR artifact"
+ value={config.params?.artifact || null}
+ placeholder="Choose a WAR module"
+ options={artifacts.map((a) => ({ value: a.id, label: `${a.name} (${a.tool}: ${a.module || "."})` }))}
+ onChange={(id) => {
+ const artifact = artifacts.find((a) => a.id === id);
+ if (artifact) select(artifact);
+ }}
+ />
+ {!artifacts.length && (
+ <span className={styles.chooserMuted}>
+ <T>No WAR modules found. Choose a WAR file or an exploded directory.</T>
+ </span>
+ )}
+ </div>
+ </div>
+ )}
+ </>
+ );
+}
diff --git a/src/features/run/configs.ts b/src/features/run/configs.ts
index 82b2dd7ca..b8d38ca98 100644
--- a/src/features/run/configs.ts
+++ b/src/features/run/configs.ts
@@ -40,11 +40,9 @@ const KIND_LABELS: Record<string, string> = {
export const KIND_OPTIONS = Object.entries(KIND_LABELS).map(([value, label]) => ({ value, label }));
export function kindLabel(kind: string): string {
- return (
- useRunConfigTypes.getState().types.get(kind)?.label ??
- KIND_LABELS[kind] ??
- (kind ? kind[0]!.toUpperCase() + kind.slice(1) : "Other")
- );
+ const type = useRunConfigTypes.getState().types.get(kind);
+ // A grouped type ("Tomcat Server › Local") is named by its group outside the Add menu.
+ return type?.group ?? type?.label ?? KIND_LABELS[kind] ?? (kind ? kind[0]!.toUpperCase() + kind.slice(1) : "Other");
}
export function configIcon(config: Pick<RunConfig, "kind" | "isTest">): string {
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index b0b1a2e19..cb3cd2748 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -42,6 +42,7 @@ import { runBeforeLaunch } from "./beforeLaunch";
import { compoundChildren } from "./configs";
import { remoteDebugBlocked } from "./remote";
import { isDebugOnly, registerBuiltinTypes } from "./types";
+import { showTomcatUpdate } from "./tomcatUpdate";
import { runGutter } from "./runGutter";
import { activateStackTrace, useStackTraces } from "./stackTrace";
import { clearRuntimeCache } from "./runtimes";
@@ -282,6 +283,14 @@ export function activate(): () => void {
prepare: prepareMenu,
}),
registerActions([
+ {
+ id: "run.updateApplication",
+ title: "Update Application",
+ category: "Run",
+ icon: "refresh",
+ when: "run.tomcatRunning",
+ run: () => showTomcatUpdate(),
+ },
{
id: "run.run",
title: "Run",
@@ -494,7 +503,13 @@ export function activate(): () => void {
]),
onIdeEvent("runExited", (e) => onRunExited(e.run, e.code)),
// Lets other title items follow the selected configuration (e.g. Build shows only for compiled ones).
- useRun.subscribe((s) => setContext("run.selectedKind", s.configs.find((c) => c.id === s.selectedId)?.kind ?? "")),
+ useRun.subscribe((s) => {
+ setContext("run.selectedKind", s.configs.find((c) => c.id === s.selectedId)?.kind ?? "");
+ setContext(
+ "run.tomcatRunning",
+ s.sessions.some((session) => session.config.kind === "tomcat" && session.status === "running"),
+ );
+ }),
useProject.subscribe((s, prev) => {
if (s.project?.root === prev.project?.root) return;
resetRuns();
diff --git a/src/features/run/javaDebug.ts b/src/features/run/javaDebug.ts
index d06f77cb9..187d02574 100644
--- a/src/features/run/javaDebug.ts
+++ b/src/features/run/javaDebug.ts
@@ -37,6 +37,7 @@ function withProperty(args: readonly string[], key: string, value: string): stri
/** The configuration with a waiting JDWP agent, or null when it starts no debuggable JVM. */
export function jdwpLaunch(config: RunConfig): RunConfig | null {
+ if (config.kind === "tomcat") return { ...config, params: { ...config.params, tomcatDebug: "true" } };
const args = config.args;
// A single source file (`java Hi.java`): the agent goes before the file.
if (config.kind === "java-file") return { ...config, args: [JDWP_AGENT, ...args] };
diff --git a/src/features/run/store.ts b/src/features/run/store.ts
index 8e3cd8091..0dcb34d29 100644
--- a/src/features/run/store.ts
+++ b/src/features/run/store.ts
@@ -38,6 +38,8 @@ import { remoteLabel, startWithRemedies } from "./remote";
import { TerminalOutput } from "./terminalOutput";
import { typeFor } from "./types";
import { startedPort } from "./serverPort";
+import { tomcatBrowserUrl } from "./tomcat";
+import { openUrl } from "./navigate";
import { tx } from "@/platform/i18n";
/** The permanent "Current File" pseudo-configuration of the chooser (runs the active file's context). */
@@ -543,7 +545,15 @@ export async function startRun(
const rt = runtimes.get(sessionId)!;
const generation = rt.generation;
if (options.onLine) rt.lineListeners.push(options.onLine);
+ let browserOpened = false;
rt.lineListeners.push((line) => {
+ if (config.kind === "tomcat" && /Server startup in/.test(line)) {
+ patchSession(sessionId, { httpPort: Number(config.params?.httpPort || "8080") });
+ if (!browserOpened && config.params?.openBrowser === "true") {
+ browserOpened = true;
+ void openUrl(tomcatBrowserUrl(config));
+ }
+ }
const port = startedPort(line);
if (port !== null && runtimes.get(sessionId)?.generation === generation && getSession(sessionId)?.httpPort !== port)
patchSession(sessionId, { httpPort: port });
@@ -585,6 +595,7 @@ export async function startRun(
const prepare = typeFor(launch.kind)?.prepareLaunch;
if (prepare) {
launch = await prepare(launch);
+ if (launch.kind === "tomcat") useRun.setState({ activeSession: sessionId });
if (runtimes.get(sessionId)?.generation !== generation) return getSession(sessionId) ?? null;
}
// Debug launches read the agent's output lines: never through a terminal.
@@ -806,7 +817,7 @@ export async function stopSession(sessionId: string): Promise<void> {
}
/** Resolves once the given sessions' processes exited (or after `timeoutMs`). */
-function waitForExit(sessionIds: readonly string[], timeoutMs = 10_000): Promise<void> {
+export function waitForExit(sessionIds: readonly string[], timeoutMs = 10_000): Promise<void> {
const live = () =>
sessionIds.some((id) => {
const s = getSession(id);
diff --git a/src/features/run/tomcat.test.tsx b/src/features/run/tomcat.test.tsx
new file mode 100644
index 000000000..2e8472bb4
--- /dev/null
+++ b/src/features/run/tomcat.test.tsx
@@ -0,0 +1,85 @@
+import { describe, expect, it, vi, afterEach } from "vitest";
+import { render, screen, waitFor, cleanup } from "@testing-library/react";
+import { newConfigOfType, missingParams } from "./types";
+import { tomcatType, tomcatBrowserUrl } from "./tomcat";
+import { jdwpLaunch } from "./javaDebug";
+import { TomcatSettings } from "./TomcatSettings";
+import { typeRows } from "./AddConfigPopup";
+import { commands } from "@/platform/ipc";
+
+vi.mock("@/platform/ipc", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/platform/ipc")>()),
+ commands: {
+ runTomcatHome: vi.fn(async () => ({ status: "ok", data: { version: "Apache Tomcat/10.1.61" } })),
+ runTomcatArtifacts: vi.fn(async () => ({
+ status: "ok",
+ data: [{ id: "maven:pom.xml", name: "hello", module: "", tool: "maven" }],
+ })),
+ },
+}));
+afterEach(cleanup);
+
+describe("Tomcat Local", () => {
+ it("offers a Local configuration grouped under Tomcat Server with build and browser defaults", () => {
+ const config = newConfigOfType(tomcatType, []);
+ expect(config.params).toMatchObject({
+ httpPort: "8080",
+ deployment: "artifact",
+ buildArtifact: "true",
+ openBrowser: "true",
+ });
+ expect(config.debugAdapter).toBe("java-debug");
+ expect(typeRows([tomcatType], "")).toEqual(
+ expect.arrayContaining([expect.objectContaining({ label: "Tomcat Server" })]),
+ );
+ expect(missingParams(config, tomcatType)).toHaveProperty("tomcatHome");
+ });
+ it("validates ports and context paths and supports manually chosen web roots", () => {
+ const config = newConfigOfType(tomcatType, []);
+ config.params = {
+ ...config.params,
+ tomcatHome: "/tomcat",
+ deployment: "directory",
+ deploymentPath: "/legacy/WebContent",
+ contextPath: "/app",
+ httpPort: "18080",
+ };
+ expect(missingParams(config, tomcatType)).toEqual({});
+ expect(tomcatBrowserUrl(config)).toBe("http://localhost:18080/app/");
+ config.params.contextPath = "/";
+ expect(tomcatBrowserUrl(config)).toBe("http://localhost:18080/");
+ config.params.httpPort = "65536";
+ config.params.contextPath = "/../app";
+ expect(missingParams(config, tomcatType)).toHaveProperty("httpPort");
+ expect(missingParams(config, tomcatType)).toHaveProperty("contextPath");
+ });
+ it("debugs through a Tomcat JDWP launch without treating an archive as a main program", () => {
+ const config = newConfigOfType(tomcatType, []);
+ const debug = jdwpLaunch(config)!;
+ expect(debug.command).toBe("catalina");
+ expect(debug.args).toEqual(["run"]);
+ expect(debug.params?.tomcatDebug).toBe("true");
+ expect(debug.env.JAVA_TOOL_OPTIONS).toBeUndefined();
+ });
+ it("shows the installation version and defaults to the project's WAR module", async () => {
+ const config = newConfigOfType(tomcatType, []);
+ config.params = { ...config.params, tomcatHome: "/tomcat" };
+ const change = vi.fn();
+ render(<TomcatSettings config={config} onChange={change} />);
+ await waitFor(() =>
+ expect(change).toHaveBeenCalledWith(
+ expect.objectContaining({
+ params: expect.objectContaining({ artifact: "maven:pom.xml", contextPath: "/hello" }),
+ }),
+ ),
+ );
+ expect(await screen.findByText("Apache Tomcat/10.1.61")).toBeTruthy();
+ });
+ it("reports an invalid installation in the form", async () => {
+ vi.mocked(commands.runTomcatHome).mockRejectedValueOnce(new Error("missing catalina.jar"));
+ const config = newConfigOfType(tomcatType, []);
+ config.params = { ...config.params, tomcatHome: "/missing" };
+ render(<TomcatSettings config={config} onChange={() => {}} />);
+ expect(await screen.findByRole("alert")).toHaveTextContent("Invalid Tomcat installation");
+ });
+});
diff --git a/src/features/run/tomcat.ts b/src/features/run/tomcat.ts
new file mode 100644
index 000000000..c6a899150
--- /dev/null
+++ b/src/features/run/tomcat.ts
@@ -0,0 +1,108 @@
+import { call, commands, type RunConfig } from "@/platform/ipc";
+import type { RunConfigTypeContribution } from "@/workbench/contributions";
+
+export const tomcatType: RunConfigTypeContribution = {
+ id: "tomcat",
+ group: "Tomcat Server",
+ label: "Local",
+ icon: "server",
+ description: "Run a WAR application in a local Tomcat server",
+ debugAdapter: "java-debug",
+ terminal: false,
+ defaults: { deployment: "artifact", httpPort: "8080", buildArtifact: "true", openBrowser: "true" },
+ fields: [
+ { key: "tomcatHome", label: "Tomcat installation directory", required: true, mono: true },
+ {
+ key: "deployment",
+ label: "Deployment",
+ control: "select",
+ options: [
+ { value: "artifact", label: "Project WAR artifact (exploded)" },
+ { value: "war", label: "WAR file" },
+ { value: "directory", label: "Exploded directory" },
+ ],
+ },
+ {
+ key: "deploymentPath",
+ label: "Deployment path",
+ mono: true,
+ required: true,
+ visible: (p) => p.deployment !== "artifact",
+ },
+ {
+ key: "contextPath",
+ label: "Context path",
+ mono: true,
+ placeholder: "/artifact-name",
+ validate: (value) =>
+ value === "/" || /^\/[\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)*$/u.test(value)
+ ? null
+ : "Enter / or a context path such as /app",
+ },
+ {
+ key: "httpPort",
+ label: "HTTP port",
+ required: true,
+ validate: (value) =>
+ /^\d+$/.test(value) && Number(value) > 0 && Number(value) <= 65535 ? null : "Port must be between 1 and 65535",
+ },
+ {
+ key: "jre",
+ label: "JRE",
+ mono: true,
+ placeholder: "Project JDK",
+ hint: "Java installation directory; empty uses the project JDK",
+ },
+ { key: "vmOptions", label: "VM options", control: "textarea", rows: 2, mono: true },
+ { key: "openBrowser", label: "Open browser after launch", control: "checkbox" },
+ {
+ key: "browserUrl",
+ label: "Browser URL",
+ mono: true,
+ placeholder: "Server URL from the HTTP port and context path",
+ visible: (p) => p.openBrowser === "true",
+ validate: (value) => (/^https?:\/\//i.test(value) ? null : "Enter an HTTP or HTTPS URL"),
+ },
+ {
+ key: "buildArtifact",
+ label: "Before launch: build the artifact",
+ control: "checkbox",
+ visible: (p) => p.deployment === "artifact",
+ },
+ ],
+ commandLine: () => ({ command: "catalina", args: ["run"] }),
+ async prepareLaunch(config) {
+ if (config.target) throw new Error("Tomcat Local requires the local machine");
+ await call(commands.runTomcatHome(config.params?.tomcatHome ?? ""));
+ if (config.params?.buildArtifact === "true") await buildTomcatArtifact(config);
+ return config;
+ },
+};
+
+export async function buildTomcatArtifact(config: RunConfig): Promise<void> {
+ const build = await call(commands.runTomcatBuild(config));
+ if (!build) return;
+ const { startRun } = await import("./store");
+ let finish!: (ok: boolean) => void;
+ const exited = new Promise<boolean>((resolve) => {
+ finish = resolve;
+ });
+ const session = await startRun(build, undefined, undefined, {
+ onExit: (code, stopped) => finish(code === 0 && !stopped),
+ });
+ if (!session || session.status === "failed" || !(await exited)) throw new Error("WAR artifact build failed");
+}
+
+export function tomcatBrowserUrl(config: RunConfig): string {
+ const p = config.params ?? {};
+ const name =
+ p.artifactName ||
+ p.deploymentPath
+ ?.replace(/\\/g, "/")
+ .split("/")
+ .pop()
+ ?.replace(/\.war$/i, "") ||
+ "";
+ const context = p.contextPath || (name && name !== "ROOT" ? `/${name}` : "/");
+ return p.browserUrl || `http://localhost:${p.httpPort || "8080"}${context === "/" ? "/" : `${context}/`}`;
+}
diff --git a/src/features/run/tomcatUpdate.test.ts b/src/features/run/tomcatUpdate.test.ts
new file mode 100644
index 000000000..631b3a20b
--- /dev/null
+++ b/src/features/run/tomcatUpdate.test.ts
@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { RunSession } from "./store";
+const mocks = vi.hoisted(() => ({
+ action: vi.fn(async () => true),
+ build: vi.fn(async () => {}),
+ update: vi.fn(async () => ({ status: "ok", data: null })),
+ start: vi.fn(async () => {}),
+ stop: vi.fn(async () => {}),
+ wait: vi.fn(async () => {}),
+ debug: true,
+}));
+vi.mock("@/platform/actions", () => ({ executeAction: mocks.action, getAction: () => ({}) }));
+vi.mock("@/platform/ipc", () => ({
+ call: async (p: Promise<{ data: unknown }>) => (await p).data,
+ commands: { runTomcatUpdate: mocks.update },
+}));
+vi.mock("@/workbench/contributions", () => ({
+ maybeEditorService: () => ({ saveAll: async () => {} }),
+ notifications: () => ({ notify: vi.fn() }),
+ useDebugRunSessions: { getState: () => ({ sessions: mocks.debug ? [{ configId: "tomcat:one" }] : [] }) },
+}));
+vi.mock("@/ui", () => ({ showContextMenu: vi.fn() }));
+vi.mock("./tomcat", () => ({ buildTomcatArtifact: mocks.build }));
+vi.mock("./store", () => ({
+ startRun: mocks.start,
+ stopSession: mocks.stop,
+ waitForExit: mocks.wait,
+ useRun: { setState: vi.fn() },
+}));
+import { updateTomcat } from "./tomcatUpdate";
+const session = { id: "run1", config: { id: "tomcat:one", kind: "tomcat" } } as RunSession;
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.debug = true;
+ mocks.action.mockResolvedValue(true);
+});
+describe("Tomcat application updates", () => {
+ it("builds and copies the deployment before requesting scoped HotSwap", async () => {
+ await updateTomcat(session, "classes");
+ expect(mocks.build).toHaveBeenCalledWith(session.config);
+ expect(mocks.update).toHaveBeenCalledWith(session.config, "classes");
+ expect(mocks.action).toHaveBeenCalledWith("debug.reloadChangedClasses", { configId: "tomcat:one" });
+ expect(mocks.build.mock.invocationCallOrder[0]).toBeLessThan(mocks.update.mock.invocationCallOrder[0]!);
+ expect(mocks.update.mock.invocationCallOrder[0]).toBeLessThan(mocks.action.mock.invocationCallOrder[0]!);
+ });
+ it("does not replace classes when updating only resources", async () => {
+ await updateTomcat(session, "resources");
+ expect(mocks.update).toHaveBeenCalledWith(session.config, "resources");
+ expect(mocks.action).not.toHaveBeenCalled();
+ });
+ it("waits for clean shutdown before restarting a debug server", async () => {
+ await updateTomcat(session, "restart");
+ expect(mocks.stop).toHaveBeenCalledWith("run1");
+ expect(mocks.wait).toHaveBeenCalledWith(["run1"]);
+ expect(mocks.wait.mock.invocationCallOrder[0]).toBeLessThan(mocks.action.mock.invocationCallOrder[0]!);
+ expect(mocks.action).toHaveBeenCalledWith("run.debugConfig", session.config);
+ });
+ it("redeploys when the debugger cannot perform HotSwap", async () => {
+ mocks.action.mockResolvedValue(false);
+ await updateTomcat(session, "classes");
+ expect(mocks.update).toHaveBeenLastCalledWith(session.config, "redeploy");
+ });
+});
diff --git a/src/features/run/tomcatUpdate.ts b/src/features/run/tomcatUpdate.ts
new file mode 100644
index 000000000..bf93a3d04
--- /dev/null
+++ b/src/features/run/tomcatUpdate.ts
@@ -0,0 +1,64 @@
+import { executeAction, getAction } from "@/platform/actions";
+import { call, commands } from "@/platform/ipc";
+import { maybeEditorService, notifications, useDebugRunSessions } from "@/workbench/contributions";
+import { showContextMenu } from "@/ui";
+import { buildTomcatArtifact } from "./tomcat";
+import { startRun, stopSession, useRun, waitForExit, type RunSession } from "./store";
+
+const updating = new Set<string>();
+export async function updateTomcat(session: RunSession, mode: string): Promise<void> {
+ if (updating.has(session.id)) return;
+ updating.add(session.id);
+ try {
+ const debugging = useDebugRunSessions.getState().sessions.some((s) => s.configId === session.config.id);
+ if (mode === "restart") {
+ if (debugging) {
+ await stopSession(session.id);
+ await waitForExit([session.id]);
+ await executeAction("run.debugConfig", session.config);
+ } else await startRun(session.config, session.id);
+ return;
+ }
+ await maybeEditorService()?.saveAll();
+ await buildTomcatArtifact(session.config);
+ await call(commands.runTomcatUpdate(session.config, mode));
+ if (mode === "classes" && debugging) {
+ const swapped =
+ getAction("debug.reloadChangedClasses") &&
+ (await executeAction("debug.reloadChangedClasses", { configId: session.config.id }));
+ if (!swapped) await call(commands.runTomcatUpdate(session.config, "redeploy"));
+ }
+ useRun.setState({ activeSession: session.id });
+ notifications().notify({ group: "run", level: "info", title: "Application updated" });
+ } catch (e) {
+ notifications().notify({ group: "run", level: "error", title: "Application update failed", body: String(e) });
+ } finally {
+ updating.delete(session.id);
+ }
+}
+
+export function showTomcatUpdate(sessionId?: string): void {
+ const state = useRun.getState();
+ const candidates = state.sessions.filter((s) => s.config.kind === "tomcat" && s.status === "running");
+ const session = candidates.find((s) => s.id === (sessionId || state.activeSession)) ?? candidates[0];
+ if (!session) return;
+ showContextMenu({ x: window.innerWidth / 2 - 140, y: 100 }, [
+ { kind: "header", label: "Update Application" },
+ ...(
+ [
+ ["resources", "Update resources"],
+ ["classes", "Update classes and resources"],
+ ["redeploy", "Redeploy"],
+ ["restart", "Restart server"],
+ ] as const
+ ).map(([mode, label]) => ({
+ label,
+ disabled:
+ updating.has(session.id) ||
+ ((mode === "resources" || mode === "classes") && session.config.params?.deployment === "war"),
+ run: () => {
+ void updateTomcat(session, mode);
+ },
+ })),
+ ]);
+}
diff --git a/src/features/run/types.ts b/src/features/run/types.ts
index c95952d6a..11333694a 100644
--- a/src/features/run/types.ts
+++ b/src/features/run/types.ts
@@ -18,6 +18,8 @@ import {
import { tx } from "@/platform/i18n";
import { useProject } from "@/platform/project";
+import { tomcatType } from "./tomcat";
+
export const COMPOUND = "compound";
const on = (v: string | undefined) => v === "true";
@@ -394,6 +396,7 @@ export const BUILTIN_TYPES: readonly RunConfigTypeContribution[] = [
pytest,
applicationType,
springBootType,
+ tomcatType,
compound,
];
diff --git a/src/platform/keymaps/intellij-macos.ts b/src/platform/keymaps/intellij-macos.ts
index 40a2386df..ae3ad64a1 100644
--- a/src/platform/keymaps/intellij-macos.ts
+++ b/src/platform/keymaps/intellij-macos.ts
@@ -254,6 +254,7 @@ export const intellijMacos: Record<string, string[]> = {
"run.debugContext": ["Ctrl+Shift+D"],
"run.stop": ["Meta+F2"],
"workbench.stopBackgroundProcesses": ["Meta+Shift+F2"],
+ "run.updateApplication": ["Meta+F10"],
// Rerun in the Run / Debug tool window only (when / keyWhen); Meta+R stays with the editor elsewhere.
"run.rerun": ["Meta+R"],
"coverage.manageReports": ["Meta+Alt+F6"],
diff --git a/src/platform/keymaps/intellij-windows.ts b/src/platform/keymaps/intellij-windows.ts
index f427af745..ce4536e19 100644
--- a/src/platform/keymaps/intellij-windows.ts
+++ b/src/platform/keymaps/intellij-windows.ts
@@ -249,6 +249,7 @@ export const intellijWindows: Record<string, string[]> = {
"run.stop": ["Ctrl+F2"],
"workbench.stopBackgroundProcesses": ["Ctrl+Shift+F2"],
// Rerun in the Run / Debug tool window only (when / keyWhen); Ctrl+F5 stays with the editor elsewhere.
+ "run.updateApplication": ["Ctrl+F10"],
"run.rerun": ["Ctrl+F5"],
"coverage.manageReports": ["Ctrl+Alt+F6"],
"debug.rerun": ["Ctrl+F5"],
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 074f9e1af..fc7bbc493 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -4907,5 +4907,53 @@
"Unarchive": "取消归档",
"Unarchive Agent Tasks": "取消归档 Agent 任务",
"Cannot unarchive agent tasks": "无法取消归档 Agent 任务",
- "Unarchive ({archived})": "取消归档({archived})"
+ "Unarchive ({archived})": "取消归档({archived})",
+ "Tomcat Server": "Tomcat 服务器",
+ "Run a WAR application in a local Tomcat server": "在本地 Tomcat 服务器中运行 WAR 应用",
+ "Tomcat installation directory": "Tomcat 安装目录",
+ "Project WAR artifact (exploded)": "项目 WAR 构件(展开目录)",
+ "WAR file": "WAR 文件",
+ "Exploded directory": "展开目录",
+ "Context path": "上下文路径",
+ "Enter / or a context path such as /app": "请输入 / 或 /app 等上下文路径",
+ "HTTP port": "HTTP 端口",
+ "JRE": "Java 运行环境",
+ "Java installation directory; empty uses the project JDK": "Java 安装目录;留空则使用项目 JDK",
+ "Open browser after launch": "启动后打开浏览器",
+ "Browser URL": "浏览器网址",
+ "Server URL from the HTTP port and context path": "根据 HTTP 端口和上下文路径生成服务器网址",
+ "Enter an HTTP or HTTPS URL": "请输入 HTTP 或 HTTPS 网址",
+ "Before launch: build the artifact": "启动前:构建部署构件",
+ "WAR artifact": "WAR 构件",
+ "Choose a WAR module": "选择 WAR 模块",
+ "No WAR modules found. Choose a WAR file or an exploded directory.": "未找到 WAR 模块。请选择 WAR 文件或展开目录。",
+ "Invalid Tomcat installation: check bin/catalina and lib/catalina.jar": "无效的 Tomcat 安装:请检查 bin/catalina 和 lib/catalina.jar",
+ "Update Application": "更新应用",
+ "Update resources": "更新资源",
+ "Update classes and resources": "更新类和资源",
+ "Redeploy": "重新部署",
+ "Restart server": "重启服务器",
+ "Application updated": "应用已更新",
+ "Application update failed": "应用更新失败",
+ "WAR artifact build failed": "WAR 构件构建失败",
+ "Tomcat Local requires the local machine": "本地 Tomcat 配置只能在本机运行",
+ "/artifact-name": "/构件名称",
+ "Choose a WAR artifact": "请选择 WAR 构件",
+ "Choose a Maven WAR module": "请选择 Maven WAR 模块",
+ "Choose a Gradle WAR module": "请选择 Gradle WAR 模块",
+ "Build the selected WAR artifact before launching Tomcat": "请先构建所选 WAR 构件,再启动 Tomcat",
+ "Build the WAR artifact before launching Tomcat": "请先构建 WAR 构件,再启动 Tomcat",
+ "The built WAR artifact does not exist": "构建的 WAR 构件不存在",
+ "Choose a WAR file or exploded directory": "请选择 WAR 文件或展开目录",
+ "Invalid Tomcat deployment": "无效的 Tomcat 部署",
+ "Unknown Tomcat deployment type": "未知的 Tomcat 部署类型",
+ "Choose a Tomcat installation directory": "请选择 Tomcat 安装目录",
+ "HTTP port must be between 1 and 65535": "HTTP 端口必须介于 1 和 65535 之间",
+ "Unknown Tomcat update operation": "未知的 Tomcat 更新操作",
+ "Start this Tomcat configuration before updating it": "请先启动此 Tomcat 配置,再更新应用",
+ "This Tomcat configuration is already running": "此 Tomcat 配置已在运行",
+ "Tomcat server.xml has no HTTP connector": "Tomcat 的 server.xml 中没有 HTTP 连接器",
+ "WAR contains an invalid path": "WAR 中包含无效路径",
+ "Context path must start with / and contain only letters, digits, /, - or _": "上下文路径必须以 / 开头,且只能包含字母、数字、/、- 或 _",
+ "Tomcat home must contain bin/catalina.sh or bin/catalina.bat and lib/catalina.jar": "Tomcat 安装目录必须包含 bin/catalina.sh 或 bin/catalina.bat,以及 lib/catalina.jar"
}