ref print_*

Cargo.lock

@@ -72,7 +72,7 @@ dependencies = [
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "reqwest 0.9.22 (registry+https://github.com/rust-lang/crates.io-index)",
  "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "rust_util 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rust_util 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "term 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "urlencoding 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1008,7 +1008,7 @@ dependencies = [
 
 [[package]]
 name = "rust_util"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1602,7 +1602,7 @@ dependencies = [
 "checksum reqwest 0.9.22 (registry+https://github.com/rust-lang/crates.io-index)" = "2c2064233e442ce85c77231ebd67d9eca395207dec2127fe0bbedde4bd29a650"
 "checksum rust-argon2 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ca4eaef519b494d1f2848fc602d18816fed808a981aedf4f1f00ceb7c9d32cf"
 "checksum rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"
-"checksum rust_util 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "35700070bf50662d748fb06926d16d24c1f7d6cfd62ba556dc58541d3c96d436"
+"checksum rust_util 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "454c4fd8ae19dd245bdc073cb297e222362adf938c3e6f0c2f8ea1abc7be2fd0"
 "checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
 "checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
 "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"

Cargo.toml

@@ -12,4 +12,4 @@ urlencoding = "1.0.0"
 dirs = "2.0.1"
 rust-crypto = "0.2.36"
 lazy_static = "1.3.0"
-rust_util = "0.2.1"
+rust_util = "0.2.3"

src/build_json.rs

@@ -5,12 +5,14 @@ use rust_util::{
     XResult,
     new_box_ioerror,
     util_msg::{
-        print_message,
+        print_ok,
-        MessageType,
+        print_debug,
+        print_warn,
+        print_error,
     }
 };
 
-use super::http::get_url;
+use super::http::get_url_content;
 use super::misc::VERBOSE;
 
 pub const BUILD_JSON: &str = "build.json";
@@ -19,16 +21,17 @@ const GET_ARCHIVER_VERSION_URL: &str= "https://hatter.ink/repo/archive_info_vers
 
 pub fn get_archive_version(gid: &str, aid: &str) -> XResult<String> {
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Start get archive info: {}:{}", gid, aid));
+        print_debug(&format!("Start get archive info: {}:{}", gid, aid));
     }
-    let mut url = String::from(GET_ARCHIVER_VERSION_URL);
+    let mut url = String::with_capacity(1024);
+    url.push_str(GET_ARCHIVER_VERSION_URL);
     url.push_str("?gid=");
     url.push_str(&urlencoding::encode(gid));
     url.push_str("&aid=");
     url.push_str(&urlencoding::encode(aid));
-    let version_result = get_url(url.as_str())?;
+    let version_result = get_url_content(url.as_str())?;
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Get archive result: {}", version_result));
+        print_debug(&format!("Get archive result: {}", version_result));
     }
     let version_result_object = json::parse(&version_result)?;
     if version_result_object["status"] != 200 {
@@ -40,7 +43,7 @@ pub fn get_archive_version(gid: &str, aid: &str) -> XResult<String> {
 
 pub fn create_build_json(args: &[String]) {
     if find_build_json_in_current().is_some() {
-        print_message(MessageType::ERROR, &format!("File exits: {}", BUILD_JSON));
+        print_error(&format!("File exits: {}", BUILD_JSON));
         return;
     }
 
@@ -59,7 +62,7 @@ pub fn create_build_json(args: &[String]) {
         }
     }
     if java_version.is_empty() || builder.is_empty() || builder_version.is_empty() {
-        print_message(MessageType::ERROR, "Args java version, builder or builder version is not assigned or format error.");
+        print_error("Args java version, builder or builder version is not assigned or format error.");
         return;
     }
     let mut build_json_object = object!{
@@ -70,7 +73,7 @@ pub fn create_build_json(args: &[String]) {
         },
     };
     match get_archive_version("me.hatter", "commons") {
-        Err(err) => print_message(MessageType::ERROR, &format!("Get me.hatter:commons version failed: {}", err)),
+        Err(err) => print_error(&format!("Get me.hatter:commons version failed: {}", err)),
         Ok(ver) => build_json_object["repo"] = object! {
             "dependencies" => array! [
                 format!("me.hatter:commons:{}", ver).as_str()
@@ -78,16 +81,16 @@ pub fn create_build_json(args: &[String]) {
         },
     }
     match fs::write(BUILD_JSON, json::stringify_pretty(build_json_object, 4)) {
-        Ok(_) => print_message(MessageType::OK, &format!("Write file success: {}", BUILD_JSON)),
+        Ok(_) => print_ok(&format!("Write file success: {}", BUILD_JSON)),
-        Err(err) => print_message(MessageType::ERROR, &format!("Write file failed: {}, error message: {}", BUILD_JSON, err)),
+        Err(err) => print_error(&format!("Write file failed: {}, error message: {}", BUILD_JSON, err)),
     }
 }
 
 pub fn find_build_json_in_current() -> Option<String> {
     let path = fs::canonicalize(".").ok()?;
-    let p_build_json = &format!("{}/{}", path.to_str()?, BUILD_JSON);
+    let p_build_json = format!("{}/{}", path.to_str()?, BUILD_JSON);
-    let path_build_json = Path::new(p_build_json);
+    let path_build_json = Path::new(&p_build_json);
-    iff!(path_build_json.exists(), Some(p_build_json.to_string()), None)
+    iff!(path_build_json.exists(), Some(p_build_json), None)
 }
 
 pub fn find_build_json_in_parents() -> Option<String> {
@@ -96,7 +99,7 @@ pub fn find_build_json_in_parents() -> Option<String> {
     loop {
         loop_count += 1_usize;
         if loop_count > 100_usize {
-            print_message(MessageType::ERROR, "Find build.json loop more than 100 loop!");
+            print_error("Find build.json loop more than 100 loop!");
             return None;
         }
 
@@ -104,10 +107,10 @@ pub fn find_build_json_in_parents() -> Option<String> {
         if p == "/" {
             return None;
         }
-        let p_build_json = &format!("{}/{}", p, BUILD_JSON);
+        let p_build_json = format!("{}/{}", p, BUILD_JSON);
-        let path_build_json = Path::new(p_build_json);
+        let path_build_json = Path::new(&p_build_json);
         if path_build_json.exists() {
-            return Some(p_build_json.to_string());
+            return Some(p_build_json);
         }
         path = path.parent()?.to_path_buf();
     }
@@ -118,11 +121,11 @@ pub fn find_build_json() -> Option<String> {
         Some(p) => Some(p),
         None => match find_build_json_in_parents() {
             Some(p) => {
-                print_message(MessageType::WARN, &format!("Cannot find {} in current dir, find: {}", BUILD_JSON, p));
+                print_warn(&format!("Cannot find {} in current dir, find: {}", BUILD_JSON, p));
                 Some(p)
             },
             None => {
-                print_message(MessageType::ERROR, &format!("Cannot find {}", BUILD_JSON));
+                print_error(&format!("Cannot find {}", BUILD_JSON));
                 None
             },
         },

src/http.rs

@@ -1,35 +1,48 @@
 use std::fs::File;
 
 use rust_util::{
+    XResult,
     util_io::copy_io,
     util_msg::{
-        print_message,
+        print_debug,
-        MessageType,
+        print_warn,
     },
-    XResult,
 };
 
 use super::misc::VERBOSE;
 
 pub fn download_url(url: &str, dest: &mut File) -> XResult<()> {
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Start download URL: {}", url));
+        print_debug(&format!("Start download URL: {}", url));
     }
     let mut response = reqwest::get(url)?;
     let header_content_length: i64 = match response.headers().get("content-length") {
         None => -1_i64,
-        Some(len_value) => len_value.to_str().unwrap().parse::<i64>().unwrap(),
+        Some(len_value) => {
+            let len_str = match len_value.to_str() {
+                Ok(len_str) => len_str, Err(err) => {
+                    print_warn(&format!("Get content length for {:?}, error: {}", len_value, err));
+                    "-1"
+                },
+            };
+            match len_str.parse::<i64>() {
+                Ok(len) => len, Err(err) => {
+                    print_warn(&format!("Get content length for {:?}, error: {}", len_value, err));
+                    -1
+                }
+            }
+        },
     };
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Content-Length: {}", header_content_length));
+        print_debug(&format!("Content-Length: {}", header_content_length));
     }
     copy_io(&mut response, dest, header_content_length)?;
     Ok(())
 }
 
-pub fn get_url(url: &str) -> XResult<String> {
+pub fn get_url_content(url: &str) -> XResult<String> {
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Get URL: {}", url));
+        print_debug(&format!("Get URL: {}", url));
     }
     Ok(reqwest::get(url)?.text()?)
 }

src/jdk.rs

@@ -6,13 +6,15 @@ use std::{
     path::Path,
     process::Command,
 };
-
+use rust_util::{
-use super::{
-    rust_util::{
     iff,
     util_os::*,
-        util_msg::*,
+    util_msg::{
+        print_error,
+        print_debug,
     },
+};
+use super::{
     local_util,
     tool,
     misc::*,
@@ -65,7 +67,7 @@ pub fn get_cloud_java(version: &str) -> bool {
             return true;
         }
     }
-    print_message(MessageType::ERROR, &format!("Get java failed, version: {}", version));
+    print_error(&format!("Get java failed, version: {}", version));
     false
 }
 
@@ -76,7 +78,7 @@ pub fn get_macos_java_home(version: &str) -> Option<String> {
     let output = Command::new(MACOS_LIBEXEC_JAVAHOME).arg("-version").arg(version).output().ok()?;
     let output_in_utf8 = str::from_utf8(&output.stderr).ok()?;
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("java_home outputs: {}", output_in_utf8));
+        print_debug(&format!("java_home outputs: {}", output_in_utf8));
     }
     if output_in_utf8.contains("Unable to find any JVMs") {
         None
@@ -92,7 +94,7 @@ pub fn get_local_java_home(version: &str) -> Option<String> {
         if let Ok(dir_entry) = path {
             if let Some(p)= dir_entry.path().to_str() {
                 if *VERBOSE {
-                    print_message(MessageType::DEBUG, &format!("Try match path: {}", p));
+                    print_debug(&format!("Try match path: {}", p));
                 }
                 let mut path_name = p;
                 if p.ends_with('/') {
@@ -109,7 +111,7 @@ pub fn get_local_java_home(version: &str) -> Option<String> {
                 };
                 if let Some(matched_path) = matched_path_opt {
                     if *VERBOSE {
-                        print_message(MessageType::DEBUG, &format!("Matched JDK path found: {}", matched_path));
+                        print_debug(&format!("Matched JDK path found: {}", matched_path));
                     }
                     return if local_util::is_path_exists(matched_path, "Contents/Home") {
                         Some(format!("{}/{}", matched_path, "Contents/Home"))
@@ -126,7 +128,7 @@ pub fn get_local_java_home(version: &str) -> Option<String> {
 pub fn extract_jdk_and_wait(file_name: &str) {
     if let Ok(local_java_home_base_dir) = local_util::get_user_home_dir(LOCAL_JAVA_HOME_BASE_DIR) {
         local_util::extract_package_and_wait(&local_java_home_base_dir, file_name).unwrap_or_else(|err| {
-            print_message(MessageType::ERROR, &format!("Extract file: {}, failed: {}", file_name, err));
+            print_error(&format!("Extract file: {}, failed: {}", file_name, err));
         });
     }
 }

src/local_util.rs

@@ -11,8 +11,7 @@ use rust_util::{
     XResult,
     new_box_ioerror,
     util_msg::{
-        print_message,
+        print_error,
-        MessageType,
     },
     util_io::*,
 };
@@ -25,16 +24,17 @@ use crypto::{
 };
 
 pub fn get_args_as_vec() -> Vec<String> {
-    let mut args_vec:Vec<String> = vec![];
+    // let mut args_vec:Vec<String> = vec![];
-    for arg in env::args() {
+    // for arg in env::args() {
-        args_vec.push(arg);
+    //     args_vec.push(arg);
-    }
+    // }
-    args_vec
+    // args_vec
+    env::args().collect::<Vec<String>>()
 }
 
 pub fn is_buildin_args(args: &[String]) -> bool {
     match args.get(1) {
-        None => return false,
+        None => false,
         Some(arg) => arg.starts_with(":::") || arg.starts_with("..."),
     }
 }
@@ -53,7 +53,7 @@ pub fn verify_file_integrity(integrity: &str, file_name: &str) -> XResult<bool>
             };
             let integrity_verify_result = digest_hex == calc_digest_hex.as_str();
             if ! integrity_verify_result {
-                print_message(MessageType::ERROR, &format!("Verify integrity failed, expected: {}, actual: {}", digest_hex, calc_digest_hex));
+                print_error(&format!("Verify integrity failed, expected: {}, actual: {}", digest_hex, calc_digest_hex));
             }
             Ok(integrity_verify_result)
         },
@@ -133,7 +133,7 @@ pub fn init_home_dir(home_sub_dir: &str) {
 pub fn init_dir(dir: &str) {
     if ! Path::new(dir).exists() {
         fs::create_dir_all(dir).unwrap_or_else(|err| {
-            print_message(MessageType::ERROR, &format!("Init dir {} failed: {}", dir, err));
+            print_error(&format!("Init dir {} failed: {}", dir, err));
         });
     }
 }

src/main.rs

@@ -22,9 +22,13 @@ use std::{
 };
 
 use rust_util::{
+    iff,
     util_msg::{
-        print_message,
+        print_ok,
-        MessageType,
+        print_info,
+        print_warn,
+        print_error,
+        print_debug,
     },
     util_cmd::run_command_and_wait,
 };
@@ -42,13 +46,13 @@ const BUILD_DATE: &str = env!("BUILD_DATE");
 fn do_with_buildin_arg_java(first_arg: &str, args: &[String]) {
     let ver = &first_arg[7..];
     if ver.is_empty() {
-        print_message(MessageType::ERROR, "Java version is not assigned!");
+        print_error("Java version is not assigned!");
         return;
     }
     match get_java_home(ver) {
-        None => print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", ver)),
+        None => print_error(&format!("Assigned java version not found: {}", ver)),
         Some(java_home) => {
-            print_message(MessageType::OK, &format!("Find java home: {}", java_home));
+            print_ok(&format!("Find java home: {}", java_home));
             let java_bin = &format!("{}/bin/java", java_home);
             let mut cmd = Command::new(java_bin);
             cmd.envs(&get_env_with_java_home(&java_home));
@@ -56,7 +60,7 @@ fn do_with_buildin_arg_java(first_arg: &str, args: &[String]) {
                 cmd.args(&args[2..]);
             }
             run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-                print_message(MessageType::ERROR, &format!("Exec java failed: {}", err));
+                print_error(&format!("Exec java failed: {}", err));
             });
         },
     };
@@ -72,32 +76,32 @@ fn do_with_buildin_arg_gradle(first_arg: &str, args: &[String]) {
 
 fn do_with_buildin_arg_config(_first_arg: &str, args: &[String]) {
     if args.len() <= 2 {
-        print_message(MessageType::ERROR, "No arguments, get or set.");
+        print_error("No arguments, get or set.");
         return;
     }
     match args[2].as_str() {
         "get" => match get_tool_package_secret() {
-            Err(_) => print_message(MessageType::WARN, "No config found."),
+            Err(_) => print_warn("No config found."),
-            Ok(secret) => print_message(MessageType::OK, &format!("Config secret: {}", secret)),
+            Ok(secret) => print_ok(&format!("Config secret: {}", secret)),
         },
         "set" => {
             if args.len() < 4 {
-                print_message(MessageType::ERROR, "Need secret for set, :::config set <secret>");
+                print_error("Need secret for set, :::config set <secret>");
             } else {
                 match set_tool_package_secret(&args[3]) {
-                    Err(err) => print_message(MessageType::ERROR, &format!("Config secret failed: {}", err)),
+                    Err(err) => print_error(&format!("Config secret failed: {}", err)),
-                    Ok(_) => print_message(MessageType::OK, "Config secret success."),
+                    Ok(_) => print_ok("Config secret success."),
                 }
             }
         },
-        arg => print_message(MessageType::ERROR, &format!("Unknown argument: {}", arg))
+        arg => print_error(&format!("Unknown argument: {}", arg))
     }
 }
 
 fn do_with_buildin_arg_builder(first_arg: &str, args: &[String], builder_name: &str) {
     let builder_version = &first_arg[(builder_name.len() + 3)..];
     if builder_version.is_empty() {
-        print_message(MessageType::ERROR, "Builder version is not assigned!");
+        print_error("Builder version is not assigned!");
         return;
     }
     let mut has_java = false;
@@ -108,7 +112,7 @@ fn do_with_buildin_arg_builder(first_arg: &str, args: &[String], builder_name: &
         if !java_version.is_empty() {
             java_home = match get_java_home(java_version) {
                 Some(h) => h, None => {
-                    print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", java_version));
+                    print_error(&format!("Assigned java version not found: {}", java_version));
                     return;
                 },
             };
@@ -116,32 +120,28 @@ fn do_with_buildin_arg_builder(first_arg: &str, args: &[String], builder_name: &
     }
     let builder_desc = match tool::get_builder_home(builder_name, builder_version) {
         Some(h) => h, None => {
-            print_message(MessageType::ERROR, &format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
+            print_error(&format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
             return;
         },
     };
     if has_java {
-        print_message(MessageType::OK, &format!("JAVA_HOME    = {}", java_home));
+        print_ok(&format!("JAVA_HOME    = {}", java_home));
     }
-    print_message(MessageType::OK, &format!("BUILDER_HOME = {}", &builder_desc.home));
+    print_ok(&format!("BUILDER_HOME = {}", &builder_desc.home));
 
-    let mut new_env = if has_java {
+    let mut new_env = iff!(has_java, get_env_with_java_home(&java_home), get_env());
-        get_env_with_java_home(&java_home)
-    } else {
-        get_env()
-    };
     for builder_home_name in builder_desc.get_builder_home_name() {
         new_env.insert(builder_home_name, builder_desc.home.clone());
     }
 
     let mut cmd = Command::new(builder_desc.get_builder_bin());
     cmd.envs(&new_env);
-    let from_index = if has_java { 3 } else { 2 };
+    let from_index = iff!(has_java, 3, 2);
     for arg in args.iter().skip(from_index) {
         cmd.arg(&arg);
     }
     run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run build command failed: {}", err));
+        print_error(&format!("Run build command failed: {}", err));
     });
 }
 
@@ -151,7 +151,7 @@ fn do_with_buildin_arg_ddd(first_arg: &str, args: &[String]) {
     };
     let build_json_object_xrun = &build_json_object["xRuns"][&first_arg[3..]];
     if build_json_object_xrun.is_null() {
-        print_message(MessageType::ERROR, &format!("Cannot find build.json#xRuns#{}", &first_arg[3..]));
+        print_error(&format!("Cannot find build.json#xRuns#{}", &first_arg[3..]));
         return;
     }
     let cmd_name = build_json_object_xrun[0].to_string();
@@ -171,10 +171,10 @@ fn do_with_buildin_arg_ddd(first_arg: &str, args: &[String]) {
         cmd.arg(arg.to_string());
     }
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Running cmd: {}, args: {:?}", &cmd_name, cmd_args));
+        print_debug(&format!("Running cmd: {}, args: {:?}", &cmd_name, cmd_args));
     }
     run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run xRun command failed: {}", err));
+        print_error(&format!("Run xRun command failed: {}", err));
     });
 }
 
@@ -197,7 +197,7 @@ fn do_with_buildin_args(args: &[String]) {
     } else if first_arg.starts_with("...") {
         do_with_buildin_arg_ddd(first_arg, args);
     } else {
-        print_message(MessageType::ERROR, &format!("Unknown args: {:?}", &args));
+        print_error(&format!("Unknown args: {:?}", &args));
     }
 }
 
@@ -207,31 +207,31 @@ fn get_java_and_builder(build_json_object: &json::JsonValue) -> Option<(String,
     let builder_version_j = &build_json_object["builder"]["version"];
 
     if java_version_j.is_null() {
-        print_message(MessageType::ERROR, "Java version is not assigned!");
+        print_error("Java version is not assigned!");
         return None;
     }
     if builder_name_j.is_null() || builder_version_j.is_null() {
-        print_message(MessageType::ERROR, "Builder name or version is not assigned!");
+        print_error("Builder name or version is not assigned!");
         return None;
     }
     let java_version = java_version_j.as_str().unwrap();
     let builder_name = builder_name_j.as_str().unwrap();
     let builder_version = builder_version_j.as_str().unwrap();
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Java version: {}", java_version));
+        print_debug(&format!("Java version: {}", java_version));
-        print_message(MessageType::DEBUG, &format!("Builder name: {}", builder_name));
+        print_debug(&format!("Builder name: {}", builder_name));
-        print_message(MessageType::DEBUG, &format!("Builder version: {}", builder_version));
+        print_debug(&format!("Builder version: {}", builder_version));
     }
 
     let java_home = match get_java_home(java_version) {
         Some(h) => h, None => {
-            print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", java_version));
+            print_error(&format!("Assigned java version not found: {}", java_version));
             return None;
         },
     };
     let builder_desc = match tool::get_builder_home(builder_name, builder_version) {
         Some(h) => h, None => {
-            print_message(MessageType::ERROR, &format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
+            print_error(&format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
             return None;
         },
     };
@@ -246,9 +246,9 @@ fn get_final_args(args: &[String], build_json_object: &json::JsonValue) -> Optio
             let a_cmd = &arg1[2..];
             let a_cmd_j = &build_json_object["xArgs"][a_cmd];
             if a_cmd_j.is_null() {
-                print_message(MessageType::WARN, &format!("xArgs argument not found: {}", a_cmd));
+                print_warn(&format!("xArgs argument not found: {}", a_cmd));
                 if args.len() == 2 {
-                    print_message(MessageType::ERROR, "Only one xArgs argument, exit.");
+                    print_error("Only one xArgs argument, exit.");
                     return None;
                 }
                 final_args.push(arg1.to_string());
@@ -276,7 +276,7 @@ fn process_envs(the_env: &mut HashMap<String, String>, build_json_object: &json:
     if ! envs_j.is_null() {
         for env in envs_j.members() {
             if *VERBOSE {
-                print_message(MessageType::DEBUG, &format!("Env: {}", env));
+                print_debug(&format!("Env: {}", env));
             }
             let env_k = &env[0];
             let env_v = &env[1];
@@ -306,13 +306,13 @@ fn read_build_json_object_from_env() -> Option<json::JsonValue> {
                     "version" => builder_version[5..],
                 };
             } else {
-                print_message(MessageType::WARN, &format!("Unknown builder: {}", builder_version));
+                print_warn(&format!("Unknown builder: {}", builder_version));
             }
         }
         if *VERBOSE {
-            print_message(MessageType::DEBUG, &format!("Use env configed build.json: {}",  json::stringify(build_json_object.clone())));
+            print_debug(&format!("Use env configed build.json: {}",  json::stringify(build_json_object.clone())));
         }
-        print_message(MessageType::OK, "Find build.json @ENV");
+        print_ok("Find build.json @ENV");
         Some(build_json_object)
     } else {
         None
@@ -328,16 +328,16 @@ fn read_build_json_object() -> Option<json::JsonValue> {
         Some(p) => p, None => return None,
     };
 
-    print_message(MessageType::OK, &format!("Find {} @ {}", BUILD_JSON, build_json));
+    print_ok(&format!("Find {} @ {}", BUILD_JSON, build_json));
     let build_json_content = match fs::read_to_string(build_json) {
         Ok(content) => content, Err(err) => {
-            print_message(MessageType::ERROR, &format!("Read {} failed: {}", BUILD_JSON, err));
+            print_error(&format!("Read {} failed: {}", BUILD_JSON, err));
             return None;
         },
     };
     match json::parse(&build_json_content) {
         Ok(object) => Some(object), Err(err) => {
-            print_message(MessageType::ERROR, &format!("Parse JSON failed: {}", err));
+            print_error(&format!("Parse JSON failed: {}", err));
             None
         },
     }
@@ -345,26 +345,26 @@ fn read_build_json_object() -> Option<json::JsonValue> {
 
 
 fn main() {
-    print_message(MessageType::INFO, &format!("{} - version {} - {}", BUILDJ, BUDERJ_VER, &GIT_HASH[0..7]));
+    print_info(&format!("{} - version {} - {}", BUILDJ, BUDERJ_VER, &GIT_HASH[0..7]));
 
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Full GIT_HASH: {}", GIT_HASH));
+        print_debug(&format!("Full GIT_HASH: {}", GIT_HASH));
-        print_message(MessageType::DEBUG, &format!("Build date: {}", BUILD_DATE));
+        print_debug(&format!("Build date: {}", BUILD_DATE));
     }
 
     let args = local_util::get_args_as_vec();
-    print_message(MessageType::INFO, &format!("Arguments: {:?}", args));
+    print_info(&format!("Arguments: {:?}", args));
 
     if (! *NOBUILDIN) && local_util::is_buildin_args(&args) {
         do_with_buildin_args(&args);
         return;
     }
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Init home dir: {}", tool::LOCAL_BUILDER_HOME_BASE_DIR));
+        print_debug(&format!("Init home dir: {}", tool::LOCAL_BUILDER_HOME_BASE_DIR));
     }
     local_util::init_home_dir(tool::LOCAL_BUILDER_HOME_BASE_DIR);
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Init home dir: {}", jdk::LOCAL_JAVA_HOME_BASE_DIR));
+        print_debug(&format!("Init home dir: {}", jdk::LOCAL_JAVA_HOME_BASE_DIR));
     }
     local_util::init_home_dir(jdk::LOCAL_JAVA_HOME_BASE_DIR);
 
@@ -377,8 +377,8 @@ fn main() {
         Some((java_home, builder_desc)) => (java_home, builder_desc),
     };
    
-    print_message(MessageType::OK, &format!("JAVA_HOME    = {}", java_home));
+    print_ok(&format!("JAVA_HOME    = {}", java_home));
-    print_message(MessageType::OK, &format!("BUILDER_HOME = {}", &builder_desc.home));
+    print_ok(&format!("BUILDER_HOME = {}", &builder_desc.home));
 
     let mut new_env = get_env_with_java_home(&java_home);
     for builder_home_name in builder_desc.get_builder_home_name() {
@@ -393,19 +393,19 @@ fn main() {
         Some(fa) => fa, None => return,
     };
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Final arguments: {:?}", &final_args));
+        print_debug(&format!("Final arguments: {:?}", &final_args));
     }
     for f_arg in final_args {
         cmd.arg(f_arg);
     }
     if *VERBOSE {
-        print_message(MessageType::DEBUG, "-----BEGIN ENVIRONMENT VARIABLES-----");
+        print_debug("-----BEGIN ENVIRONMENT VARIABLES-----");
         for (k, v) in new_env {
-            print_message(MessageType::DEBUG, &format!("{}={}", k, v));
+            print_debug(&format!("{}={}", k, v));
         }
-        print_message(MessageType::DEBUG, "-----END ENVIRONMENT VARIABLES-----");
+        print_debug("-----END ENVIRONMENT VARIABLES-----");
     }
     run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run build command failed: {}", err));
+        print_error(&format!("Run build command failed: {}", err));
     });
 }

src/misc.rs

@@ -38,7 +38,7 @@ BUILDJ_JAVA=1.8 BUILDJ_BUILDER=maven3.5.2 buildj    - direct run buildj"#);
 
 pub fn print_version() {
   println!(r#"buildj {} - {}
-Copyright (C) 2019 Hatter Jiang.
+Copyright (C) 2019-2020 Hatter Jiang.
 License MIT <https://opensource.org/licenses/MIT>
 
 Written by Hatter Jiang"#, super::BUDERJ_VER, &super::GIT_HASH[0..7]);

src/tool.rs

@@ -2,18 +2,20 @@ use std::{
     fs::{self, File},
     path::Path,
 };
-
+use rust_util::{
-use super::{
-    http,
-    rust_util::{
     XResult,
     new_box_ioerror,
     util_os::is_macos_or_linux,
     util_msg::{
-            print_message,
+        print_ok,
-            MessageType,
+        print_info,
-        },
+        print_warn,
+        print_error,
+        print_debug,
     },
+};
+use super::{
+    http::{ download_url, get_url_content, },
     local_util::{self, *},
     misc::*,
 };
@@ -60,14 +62,13 @@ impl BuilderDesc {
 
 pub fn get_builder_home(builder: &str, version: &str) -> Option<BuilderDesc> {
     let local_builder_home_base_dir = match get_user_home_dir(LOCAL_BUILDER_HOME_BASE_DIR) {
-        Err(_) => return None,
+        Ok(o) => o, Err(_) => return None,
-        Ok(o) => o,
     };
     let builder_name = match builder {
         "maven" => BuilderName::Maven,
         "gradle" => BuilderName::Gradle,
         _ => {
-            print_message(MessageType::ERROR, &format!("Unknown builder: {}", builder));
+            print_error(&format!("Unknown builder: {}", builder));
             return None;
         },
     };
@@ -89,7 +90,7 @@ pub fn get_cloud_builder(builder: &str, version: &str) -> bool {
     };
     match get_and_extract_tool_package(&local_builder_home_base_dir, true, builder, version, true) {
         Ok(_) => true, Err(err) => {
-            print_message(MessageType::ERROR, &format!("Get builder: {} failed, version: {}, error: {}", builder, version, err));
+            print_error(&format!("Get builder: {} failed, version: {}, error: {}", builder, version, err));
             false
         },
     }
@@ -98,7 +99,7 @@ pub fn get_cloud_builder(builder: &str, version: &str) -> bool {
 pub fn get_local_builder_home_sub(builder_name: BuilderName, local_builder_home_dir: &str) -> Option<BuilderDesc> {
     match get_local_builder_home_sub_first_sub_dir(local_builder_home_dir) {
         None => {
-            print_message(MessageType::ERROR, &format!("Cannot find builder home in: {}", local_builder_home_dir));
+            print_error(&format!("Cannot find builder home in: {}", local_builder_home_dir));
             None
         },
         Some(p) => Some(BuilderDesc{name: builder_name, home: p, bin: None}),
@@ -120,7 +121,7 @@ pub fn get_local_builder_home_sub_first_sub_dir(local_builder_home_dir: &str) ->
 pub fn get_tool_package_secret() -> XResult<String> {
     if (*AUTH_TOKEN).is_some() {
         if *VERBOSE {
-            print_message(MessageType::DEBUG, "Use auth token from env 'BUILDJ_AUTH_TOKEN'");
+            print_debug("Use auth token from env 'BUILDJ_AUTH_TOKEN'");
         }
         return Ok((*AUTH_TOKEN).as_ref().unwrap().clone());
     }
@@ -174,18 +175,18 @@ pub fn set_tool_package_secret(secret: &str) -> XResult<()> {
 
 pub fn get_tool_package_detail(name: &str, version: &str) -> XResult<String> {
     let secret: Option<String> = if *NOAUTH {
-        print_message(MessageType::WARN, "Running in no auth mode!");
+        print_warn("Running in no auth mode!");
         None
     } else {
         match get_tool_package_secret() {
             Ok(r) => Some(r), Err(err) => {
-                print_message(MessageType::WARN, &format!("Get package detail secret failed: {}, from file: ~/{}", err, STANDARD_CONFIG_JSON));
+                print_warn(&format!("Get package detail secret failed: {}, from file: ~/{}", err, STANDARD_CONFIG_JSON));
                 None
             },
         }
     };
     
-    let mut url = String::new();
+    let mut url = String::with_capacity(1024);
     match secret {
         None => {
             url.push_str(TOOL_PACKAGE_DETAIL_URL_WITHOUT_AUTH);
@@ -202,14 +203,14 @@ pub fn get_tool_package_detail(name: &str, version: &str) -> XResult<String> {
     url.push_str(&urlencoding::encode(name));
     url.push_str("&ver=");
     url.push_str(&urlencoding::encode(version));
-    Ok(http::get_url(url.as_str())?)
+    Ok(get_url_content(url.as_str())?)
 }
 
 pub fn get_and_extract_tool_package(base_dir: &str, dir_with_name: bool, name: &str, version: &str, extract_match: bool) -> XResult<bool> {
     let tool_package_detail = get_tool_package_detail(name, version)?;
     let build_json_object = json::parse(&tool_package_detail)?;
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Get tool {}:{}, result JSON: {}", name, version, json::stringify_pretty(build_json_object.clone(), 4)));
+        print_debug(&format!("Get tool {}:{}, result JSON: {}", name, version, json::stringify_pretty(build_json_object.clone(), 4)));
     }
     if build_json_object["status"] != 200 {
         return Err(new_box_ioerror(&format!("Error in get tool package detail: {}", build_json_object["message"])));
@@ -228,7 +229,7 @@ pub fn get_and_extract_tool_package(base_dir: &str, dir_with_name: bool, name: &
         return Err(new_box_ioerror(&format!("Required version not match, {}: {} vs {}", name, version, &v)));
     }
 
-    let mut target_base_dir = String::new(); 
+    let mut target_base_dir = String::with_capacity(512);
     target_base_dir.push_str(base_dir);
     if dir_with_name {
         target_base_dir.push_str("/");
@@ -237,17 +238,17 @@ pub fn get_and_extract_tool_package(base_dir: &str, dir_with_name: bool, name: &
     init_dir(&target_base_dir);
     let target_file_name = format!("{}/{}", &target_base_dir, name.to_string());
 
-    print_message(MessageType::INFO, &format!("Start download: {} -> {}", &url.to_string(), &target_file_name));
+    print_info(&format!("Start download: {} -> {}", &url.to_string(), &target_file_name));
-    http::download_url(&url.to_string(), &mut File::create(&target_file_name)?)?;
+    download_url(&url.to_string(), &mut File::create(&target_file_name)?)?;
 
-    print_message(MessageType::INFO, &format!("Start verify integrity: {} ...", &target_file_name));
+    print_info(&format!("Start verify integrity: {} ...", &target_file_name));
     if local_util::verify_file_integrity(&integrity.to_string(), &target_file_name)? {
-        print_message(MessageType::OK, "Verify integrity success.");
+        print_ok("Verify integrity success.");
     } else {
         return Err(new_box_ioerror("Verify integrity failed!"));
     }
 
-    print_message(MessageType::INFO, &format!("Start extract file: {}", &target_file_name));
+    print_info(&format!("Start extract file: {}", &target_file_name));
     local_util::extract_package_and_wait(&target_base_dir, &name.to_string())?;
 
     Ok(true)