/hg/icedtea-web: Implemented JVM recognition in rust launchers
jvanek at icedtea.classpath.org
jvanek at icedtea.classpath.org
Wed Sep 5 16:18:54 UTC 2018
changeset 1e7642497ca2 in /hg/icedtea-web
details: http://icedtea.classpath.org/hg/icedtea-web?cmd=changeset;node=1e7642497ca2
author: Jiri Vanek <jvanek at redhat.com>
date: Wed Sep 05 18:18:40 2018 +0200
Implemented JVM recognition in rust launchers
* .hgignore: added rust-launcher/.idea
* .Makefile: (launcher.build) adapted to tmp handling - exporting rust_tests_tmp and creating it
* rust-launcher/src/hardcoded_paths.rs: not-using returns consistently
* rust-launcher/src/jvm_from_properties.rs: logic to parse properties file, and to read JDK value from here
* rust-launcher/src/jvm_from_properties_resolver.rs: logic to waterfall all usable properties files and try locate JDK here.
* rust-launcher/src/main.rs: now trying various JDKS: proeprties->JAVA_HOME->registry->default (from build)
* rust-launcher/src/os_access.rs: set of classes serving to bridge few details where win and Linux may differ
* rust-launcher/src/property.rs: class to read generic properties file
* rust-launcher/src/utils.rs: class for various utility methods. Including testing subclass
diffstat:
.hgignore | 2 +-
ChangeLog | 15 +
Makefile.am | 2 +
rust-launcher/src/hardcoded_paths.rs | 12 +-
rust-launcher/src/jvm_from_properties.rs | 305 ++++++++++++++++++++++
rust-launcher/src/jvm_from_properties_resolver.rs | 217 +++++++++++++++
rust-launcher/src/main.rs | 59 +++-
rust-launcher/src/os_access.rs | 34 ++
rust-launcher/src/property.rs | 190 +++++++++++++
rust-launcher/src/utils.rs | 126 +++++++++
10 files changed, 949 insertions(+), 13 deletions(-)
diffs (truncated from 1044 to 500 lines):
diff -r 2fa722d9abfd -r 1e7642497ca2 .hgignore
--- a/.hgignore Mon Aug 13 16:47:25 2018 +0200
+++ b/.hgignore Wed Sep 05 18:18:40 2018 +0200
@@ -14,4 +14,4 @@
netx-dist-tests-whitelist
rust-launcher/target
rust-launcher/Cargo.lock
-
+rust-launcher/.idea
diff -r 2fa722d9abfd -r 1e7642497ca2 ChangeLog
--- a/ChangeLog Mon Aug 13 16:47:25 2018 +0200
+++ b/ChangeLog Wed Sep 05 18:18:40 2018 +0200
@@ -1,3 +1,18 @@
+2018-09-05 Jiri Vanek <jvanek at redhat.com>
+
+ Implemented JVM recognition in rust launchers
+ * .hgignore: added rust-launcher/.idea
+ * .Makefile: (launcher.build) adapted to tmp handling - exporting rust_tests_tmp and creating it
+ * rust-launcher/src/hardcoded_paths.rs: not-using returns consistently
+ * rust-launcher/src/jvm_from_properties.rs: logic to parse properties file, and to read JDK value from here
+ * rust-launcher/src/jvm_from_properties_resolver.rs: logic to waterfall all usable properties files and try
+ locate JDK here.
+ * rust-launcher/src/main.rs: now trying various JDKS: proeprties->JAVA_HOME->registry->default (from build)
+ * rust-launcher/src/os_access.rs: set of classes serving to bridge few details where win and Linux may differ
+ * rust-launcher/src/property.rs: class to read generic properties file
+ * rust-launcher/src/utils.rs: class for various utility methods. Including testing subclass
+
+
2018-08-13 Jiri Vanek <jvanek at redhat.com>
* LICENSE: new file. Added explicit license with details
diff -r 2fa722d9abfd -r 1e7642497ca2 Makefile.am
--- a/Makefile.am Mon Aug 13 16:47:25 2018 +0200
+++ b/Makefile.am Wed Sep 05 18:18:40 2018 +0200
@@ -878,6 +878,8 @@
# there is curently harecoded sh, so it can somehow basically work
# see the DESKTOP_SUFFIX for final tuning
launcher.build/$(javaws) launcher.build/$(itweb_settings) launcher.build/$(policyeditor): rust-launcher/src/main.rs rust-launcher/Cargo.toml
+ export ITW_TMP_REPLACEMENT=$(TESTS_DIR)/rust_tests_tmp ; \
+ mkdir -p $$ITW_TMP_REPLACEMENT; \
filename=`basename $@` ; \
type=$${filename%.*} ; \
srcs=$(TOP_SRC_DIR)/rust-launcher ; \
diff -r 2fa722d9abfd -r 1e7642497ca2 rust-launcher/src/hardcoded_paths.rs
--- a/rust-launcher/src/hardcoded_paths.rs Mon Aug 13 16:47:25 2018 +0200
+++ b/rust-launcher/src/hardcoded_paths.rs Wed Sep 05 18:18:40 2018 +0200
@@ -12,33 +12,31 @@
pub fn get_jre() -> &'static str {
- return JRE.unwrap_or("JRE-dev-unspecified")
+ JRE.unwrap_or("JRE-dev-unspecified")
}
pub fn get_java() -> &'static str {
- return JAVA.unwrap_or("JAVA-dev-unspecified")
+ JAVA.unwrap_or("JAVA-dev-unspecified")
}
pub fn get_main() -> &'static str {
- return MAIN_CLASS.unwrap_or("MAIN_CLASS-dev-unspecified")
+ MAIN_CLASS.unwrap_or("MAIN_CLASS-dev-unspecified")
}
pub fn get_name() -> &'static str {
- return PROGRAM_NAME.unwrap_or("PROGRAM_NAME-dev-unspecified")
+ PROGRAM_NAME.unwrap_or("PROGRAM_NAME-dev-unspecified")
}
pub fn get_bin() -> &'static str {
- return BIN_LOCATION.unwrap_or("BIN_LOCATION-dev-unspecified")
+ BIN_LOCATION.unwrap_or("BIN_LOCATION-dev-unspecified")
}
-
/*new variables*/
/*tests*/
#[cfg(test)]
mod tests {
-
#[test]
fn variables_non_default() {
assert_ne!(String::from(super::get_jre()).trim(), String::from("JRE-dev-unspecified"));
diff -r 2fa722d9abfd -r 1e7642497ca2 rust-launcher/src/jvm_from_properties.rs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rust-launcher/src/jvm_from_properties.rs Wed Sep 05 18:18:40 2018 +0200
@@ -0,0 +1,305 @@
+use property;
+
+use std;
+use std::env;
+use std::string::String;
+use std::fs::File;
+
+static ICEDTEA_WEB: &'static str = "icedtea-web";
+pub static DEPLOYMENT_PROPERTIES: &'static str = "deployment.properties";
+pub static PROPERTY_NAME: &'static str = "deployment.jre.dir";
+
+fn is_file(path: &std::path::PathBuf) -> bool {
+ let mdr = path.metadata();
+ match mdr {
+ Ok(md) => md.is_file(),
+ Err(_e) => false
+ }
+}
+
+fn get_home() -> Option<std::path::PathBuf> {
+ match env::home_dir() {
+ Some(p) => Some(p),
+ None => None
+ }
+}
+
+fn get_config_dir() -> Option<std::path::PathBuf> {
+ match env::var("XDG_CONFIG_HOME") {
+ Ok(war) => {
+ Some(std::path::PathBuf::from(war))
+ }
+ Err(_e) => {
+ match get_home() {
+ Some(mut p) => {
+ p.push(".config");
+ Some(p)
+ }
+ None => None
+ }
+ }
+ }
+}
+
+pub fn get_itw_config_dir() -> Option<std::path::PathBuf> {
+ match get_config_dir() {
+ Some(mut p) => {
+ p.push(ICEDTEA_WEB);
+ Some(p)
+ }
+ None => None
+ }
+}
+
+
+pub fn get_itw_legacy_config_dir() -> Option<std::path::PathBuf> {
+ match get_home() {
+ Some(mut p) => {
+ p.push(".icedtea");
+ Some(p)
+ }
+ None => None
+ }
+}
+
+
+pub fn get_itw_config_file() -> Option<std::path::PathBuf> {
+ match get_itw_config_dir() {
+ Some(mut p) => {
+ p.push(DEPLOYMENT_PROPERTIES);
+ Some(p)
+ }
+ None => None
+ }
+}
+
+pub fn get_itw_legacy_config_file() -> Option<std::path::PathBuf> {
+ match get_itw_legacy_config_dir() {
+ Some(mut p) => {
+ p.push(DEPLOYMENT_PROPERTIES);
+ Some(p)
+ }
+ None => None
+ }
+}
+
+
+pub fn get_itw_legacy_global_config_file() -> Option<std::path::PathBuf> {
+ let mut path = std::path::PathBuf::from("/etc/.java/.deploy");
+ path.push(DEPLOYMENT_PROPERTIES);
+ Some(path)
+}
+
+pub fn get_itw_global_config_file() -> Option<std::path::PathBuf> {
+ let mut path = std::path::PathBuf::from("/etc/.java/deployment");
+ path.push(DEPLOYMENT_PROPERTIES);
+ Some(path)
+}
+
+
+pub fn check_file_for_property_jredir(file: File) -> Option<String> {
+ check_file_for_property(file, PROPERTY_NAME)
+}
+
+fn check_file_for_property(file: File, key: &str) -> Option<String> {
+ let p = property::Property::load(file, key);
+ match p {
+ None => { None }
+ Some(property) => {
+ Some(property.value)
+ }
+ }
+}
+
+
+pub fn get_jre_from_file(file: Option<std::path::PathBuf>) -> Option<String> {
+ match file {
+ None => None,
+ Some(path) => {
+ get_jre_from_file_direct(path)
+ }
+ }
+}
+
+fn get_jre_from_file_direct(path: std::path::PathBuf) -> Option<String> {
+ if !path.exists() {
+ None
+ } else if !is_file(&path) {
+ return None;
+ } else {
+ let fileresult = File::open(path);
+ match fileresult {
+ Err(_fe) => None,
+ Ok(file) => {
+ let result = check_file_for_property_jredir(file);
+ result
+ }
+ }
+ }
+}
+
+pub fn verify_jdk_string(file: &String) -> bool {
+ verify_jdk_path(&std::path::PathBuf::from(file))
+}
+
+fn verify_jdk_path(ffile: &std::path::PathBuf) -> bool {
+ let mut file = ffile.clone();
+ file.push("bin");
+ file.push("java");
+ if !file.exists() {
+ false
+ } else if !is_file(&file) {
+ false
+ } else {
+ true
+ }
+}
+
+/*tests*/
+#[cfg(test)]
+mod tests {
+ use std;
+ use std::fs::File;
+ use utils::tests_utils as tu;
+
+
+ #[test]
+ fn is_not_file_() {
+ let r = super::is_file(&std::path::PathBuf::from("/definitely/not/existing/file"));
+ assert_eq!(false, r);
+ }
+
+ #[test]
+ fn is_file_() {
+ let dir = tu::create_tmp_file();
+ let r = super::is_file(&dir);
+ tu::debuggable_remove_file(&dir);
+ assert_eq!(true, r);
+ }
+
+ #[test]
+ fn check_file_for_property_jredir_not_found() {
+ let path = tu::create_tmp_file();
+ let f = File::open(&path);
+ let prop = super::check_file_for_property_jredir(f.expect("file was not opened"));
+ tu::debuggable_remove_file(&path);
+ assert_eq!(None, prop);
+ }
+
+ #[test]
+ fn check_file_for_property_jredir() {
+ let path = tu::create_tmp_propfile_with_content();
+ let f = File::open(&path);
+ let prop = super::check_file_for_property_jredir(f.expect("file was not opened"));
+ tu::debuggable_remove_file(&path);
+ assert_eq!("/some/jre", prop.expect("property was supposed to be loaded"));
+ }
+
+
+ #[test]
+ fn check_file_for_property_not_found() {
+ let path = tu::create_tmp_propfile_with_content();
+ let f = File::open(&path);
+ let k = "not_existing_key";
+ let prop = super::check_file_for_property(f.expect("file was not opened"), k);
+ tu::debuggable_remove_file(&path);
+ assert_eq!(None, prop);
+ }
+
+ #[test]
+ fn check_file_for_property_item_exists() {
+ let path = tu::create_tmp_propfile_with_content();
+ let f = File::open(&path);
+ let k = "key2";
+ let prop = super::check_file_for_property(f.expect("file was not opened"), k);
+ tu::debuggable_remove_file(&path);
+ assert_eq!("val2", prop.expect("property was supposed to be loaded"));
+ }
+
+ #[test]
+ fn get_jre_from_file_exists() {
+ let path = tu::create_tmp_propfile_with_content();
+ let prop = super::get_jre_from_file(Some(path.clone()));
+ tu::debuggable_remove_file(&path);
+ assert_eq!("/some/jre", prop.expect("property was supposed to be loaded"));
+ }
+
+ #[test]
+ fn get_jre_from_file_not_found() {
+ let path = tu::create_tmp_file();
+ let prop = super::get_jre_from_file(Some(path.clone()));
+ tu::debuggable_remove_file(&path);
+ assert_eq!(None, prop);
+ }
+
+
+ #[test]
+ fn get_jre_from_file_notexists() {
+ let path = tu::create_tmp_file();
+ tu::debuggable_remove_file(&path);
+ let prop = super::get_jre_from_file(Some(path));
+ assert_eq!(None, prop);
+ }
+
+ #[test]
+ fn get_jre_from_file_none() {
+ let prop = super::get_jre_from_file(None);
+ assert_eq!(None, prop);
+ }
+
+ #[test]
+ fn verify_jdk_string_verify_jdk_path_jdk_ok() {
+ let master_dir = tu::fake_jre(true);
+ let vs = super::verify_jdk_string(&master_dir.display().to_string());
+ let vp = super::verify_jdk_path(&master_dir);
+ tu::debuggable_remove_dir(&master_dir);
+ assert_eq!(true, vs);
+ assert_eq!(true, vp);
+ }
+
+ #[test]
+ fn verify_jdk_string_verify_jdk_path_jdk_bad() {
+ let master_dir = tu::fake_jre(false);
+ let vs = super::verify_jdk_string(&master_dir.display().to_string());
+ let vp = super::verify_jdk_path(&master_dir);
+ tu::debuggable_remove_dir(&master_dir);
+ assert_eq!(false, vs);
+ assert_eq!(false, vp);
+ }
+
+ #[test]
+ fn check_config_files_paths() {
+ let p1 = super::get_itw_config_dir();
+ let p2 = super::get_itw_legacy_config_dir();
+ let p3 = super::get_itw_config_file();
+ let p4 = super::get_itw_legacy_config_file();
+ let p5 = super::get_itw_legacy_global_config_file();
+ let p6 = super::get_itw_global_config_file();
+ assert_ne!(None, p1);
+ assert_ne!(None, p2);
+ assert_ne!(None, p3);
+ assert_ne!(None, p4);
+ assert_ne!(None, p5);
+ assert_ne!(None, p6);
+ println!("{}", p1.clone().expect("unwrap failed").display());
+ println!("{}", p2.clone().expect("unwrap failed").display());
+ println!("{}", p3.clone().expect("unwrap failed").display());
+ println!("{}", p4.clone().expect("unwrap failed").display());
+ println!("{}", p5.clone().expect("unwrap failed").display());
+ println!("{}", p6.clone().expect("unwrap failed").display());
+ assert_eq!(true, p1.clone().expect("unwrap failed").display().to_string().contains("icedtea-web"));
+ assert_eq!(true, p2.clone().expect("unwrap failed").display().to_string().contains(".icedtea"));
+ assert_eq!(true, p3.clone().expect("unwrap failed").display().to_string().contains("icedtea-web"));
+ assert_eq!(true, p3.clone().expect("unwrap failed").display().to_string().ends_with("deployment.properties"));
+ assert_eq!(true, p4.clone().expect("unwrap failed").display().to_string().contains(".icedtea"));
+ assert_eq!(true, p4.clone().expect("unwrap failed").display().to_string().ends_with("deployment.properties"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains("etc"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains(".java"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains(".deploy"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().ends_with("deployment.properties"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains("etc"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains(".java"));
+ assert_eq!(true, p5.clone().expect("unwrap failed").display().to_string().contains("deployment"));
+ assert_eq!(true, p6.clone().expect("unwrap failed").display().to_string().ends_with("deployment.properties"));
+ }
+}
diff -r 2fa722d9abfd -r 1e7642497ca2 rust-launcher/src/jvm_from_properties_resolver.rs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rust-launcher/src/jvm_from_properties_resolver.rs Wed Sep 05 18:18:40 2018 +0200
@@ -0,0 +1,217 @@
+use hardcoded_paths;
+use jvm_from_properties;
+use os_access;
+
+use std;
+use std::string::String;
+use std::fmt::Write;
+
+pub fn try_jdk_from_properties(logger: &os_access::Os) -> Option<String> {
+ let array: [Option<std::path::PathBuf>; 4] = [
+ jvm_from_properties::get_itw_config_file(),
+ jvm_from_properties::get_itw_legacy_config_file(),
+ jvm_from_properties::get_itw_legacy_global_config_file(),
+ jvm_from_properties::get_itw_global_config_file()
+ ];
+ try_jdk_from_properties_files(logger, &array)
+}
+
+fn try_jdk_from_properties_files(logger: &os_access::Os, array: &[Option<std::path::PathBuf>]) -> Option<String> {
+ for jdk in array {
+ let mut info1 = String::new();
+ write!(&mut info1, "{} ", "itw-rust-debug: checking jre in:").expect("unwrap failed");
+ write!(&mut info1, "{}", jdk.clone().unwrap_or(std::path::PathBuf::from("None")).display()).expect("unwrap failed");
+ logger.log(&info1);
+ match jvm_from_properties::get_jre_from_file(jdk.clone()) {
+ Some(path) => {
+ let mut info2 = String::new();
+ write!(&mut info2, "{} ", "itw-rust-debug: located").expect("unwrap failed");
+ write!(&mut info2, "{}", path).expect("unwrap failed");
+ write!(&mut info2, " in file {}", jdk.clone().expect("file should be already verified").display()).expect("unwrap failed");
+ logger.log(&info2);
+ if jvm_from_properties::verify_jdk_string(&path) {
+ return Some(path);
+ } else {
+ //the only output out of verbose mode
+ let mut res = String::new();
+ write!(&mut res, "{}", "Your custom JRE ").expect("unwrap failed");
+ write!(&mut res, "{}", path).expect("unwrap failed");
+ write!(&mut res, "{}", " read from ").expect("unwrap failed");
+ write!(&mut res, "{}", jdk.clone().expect("jre path should be loaded").display()).expect("unwrap failed");
+ write!(&mut res, "{}", " under key ").expect("unwrap failed");
+ write!(&mut res, "{}", jvm_from_properties::PROPERTY_NAME).expect("unwrap failed");
+ write!(&mut res, "{}", " is not valid. Trying other config files, then using default (").expect("unwrap failed");
+ write!(&mut res, "{}", hardcoded_paths::get_java()).expect("unwrap failed");
+ write!(&mut res, "{}", ", ").expect("unwrap failed");
+ write!(&mut res, "{}", hardcoded_paths::get_jre()).expect("unwrap failed");
+ write!(&mut res, "{}", ", registry or JAVA_HOME) in attempt to start. Please fix this.").expect("unwrap failed");
+ logger.info(&res);
+ }
+ }
+ None => {
+ logger.log("itw-rust-debug: property not located or file inaccessible");
+ }
+ }
+ }
+ None
+}
+
+/*tests*/
+/*To print the diagnostic output use `cargo test -- --nocapture
+`*/
+#[cfg(test)]
+mod tests {
+ use std;
+ use os_access;
+ use std::cell::RefCell;
+ use utils::tests_utils as tu;
+ //if you wont to investigate files used for testing
+ // use cargo test -- --nocapture to see files which needs delete
+ static DELETE_TEST_FILES: bool = true;
+
+ pub struct TestLogger {
+ vec: RefCell<Vec<String>>,
+ }
+
+ impl TestLogger {
+ fn get_log(&self) -> String {
+ let joined = self.vec.borrow_mut().join("; ");
+ joined
+ }
+ }
+
+ impl os_access::Os for TestLogger {
+ fn log(&self, s: &str) {
+ let ss = String::from(s);
+ self.vec.borrow_mut().push(ss);
+ }
+
+ fn info(&self, s: &str) {
+ let ss = String::from(s);
+ self.vec.borrow_mut().push(ss);
+ }
+
+ fn get_registry_jdk(&self) -> Option<std::path::PathBuf> {
+ None
+ }
+ }
+
+ #[test]
+ fn try_jdk_from_properties_files_4nothing() {
+ let array: [Option<std::path::PathBuf>; 4] = [
+ None,
More information about the distro-pkg-dev
mailing list