feat: update version

.gitignore

@@ -1,6 +1,7 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
+.idea/
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

CNAME

@@ -0,0 +1 @@
+buildj.ruststack.org

Cargo.toml

@@ -1,15 +1,19 @@
 [package]
 name = "buildj"
-version = "0.1.2"
+version = "0.1.10"
 authors = ["Hatter Jiang <jht5945@gmail.com>"]
 edition = "2018"
+homepage = "https://buildj.ruststack.org/"
+license = "MIT"
+description = "A java build tool"
 
 [dependencies]
-json = "0.11.14"
-term = "0.5.2"
-reqwest = "0.9.18"
-urlencoding = "1.0.0"
-dirs = "2.0.1"
-rust-crypto = "0.2.36"
-lazy_static = "1.3.0"
-rust_util = { git = "https://github.com/jht5945/rust_util" }
+json = "0.12"
+term = "0.7"
+reqwest = { version = "0.11", features = [ "blocking" ] }
+urlencoding = "1.1"
+dirs = "3.0"
+rust-crypto = "0.2"
+lazy_static = "1.4"
+rust_util = "0.6"
+plist = "1.1"

README.md

@@ -1,15 +1,19 @@
 # buildj
-buildj - java build tool
+buildj - java build tool, website: [https://buildj.ruststack.org/](https://buildj.ruststack.org/)
 
-#### Install
+## Install
 
 ```
 cargo install --git https://github.com/jht5945/buildj [--force]
+
+OR
+
+cargo install buildj [--force]
 ```
 
-#### Usage
+## Usage
 
-Help:
+### Help
 ```
 $ buildj :::
 [INFO] buildj - version 0.1
@@ -25,7 +29,7 @@ buildj :::gradle<version> ]--java<version>]            - run gradle with assigne
 buildj                                                 - run build, run assigned version builder tool
 ```
 
-Run Java:
+### Run Java
 ```
 $ buildj :::java9 -version
 [INFO] buildj - version 0.1
@@ -50,7 +54,7 @@ Default locale: en_US, platform encoding: UTF-8
 OS name: "mac os x", version: "10.14.4", arch: "x86_64", family: "mac"
 ```
 
-Run Gradle:
+### Run Gradle
 ```
 $ buildj :::gradle3.5.1 -version
 [INFO] buildj - version 0.1
@@ -127,6 +131,3 @@ Use xRuns in build:
 ```
 Command: `buildj ...pub`
 
-
-
-

_config.yml

@@ -0,0 +1,2 @@
+theme: jekyll-theme-slate
+show_downloads: true

build.rs

@@ -7,4 +7,7 @@ fn main() {
     let date_output = Command::new("date").args(&["+%Y-%m-%dT%H:%M:%S%z"]).output().unwrap();
     let date = String::from_utf8(date_output.stdout).unwrap();
     println!("cargo:rustc-env=BUILD_DATE={}", date);
+    let date_year_output = Command::new("date").args(&["+%Y"]).output().unwrap();
+    let date_year = String::from_utf8(date_year_output.stdout).unwrap();
+    println!("cargo:rustc-env=BUILD_YEAR={}", date_year)
 }

src/build_json.rs

@@ -1,19 +1,8 @@
-use std::{
-    fs,
-    path::Path,
-};
+use std::{fs, path::Path};
+use rust_util::XResult;
 
-use rust_util::{
-    XResult,
-    new_box_ioerror,
-    util_msg::{
-        print_message,
-        MessageType,
-    }
-};
-
-use super::http::get_url;
-use super::misc::VERBOSE;
+use crate::http::get_url_content;
+use crate::misc::VERBOSE;
 
 pub const BUILD_JSON: &str = "build.json";
 
@@ -21,32 +10,30 @@ 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));
+        debugging!("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));
+        debugging!("Get archive result: {}", version_result);
     }
     let version_result_object = json::parse(&version_result)?;
     if version_result_object["status"] != 200 {
-        Err(new_box_ioerror(&format!("Get archive info version failed: {}", version_result)))
+        simple_error!("Get archive info version failed: {}", version_result)
     } else {
         Ok(version_result_object["data"].to_string())
     }
 }
 
-pub fn create_build_json(args: &Vec<String>) {
-    match find_build_json_in_current() {
-        Some(_) => {
-            print_message(MessageType::ERROR, &format!("File exits: {}", BUILD_JSON));
-            return;
-        }, 
-        None => (), // OK
+pub fn create_build_json(args: &[String]) {
+    if find_build_json_in_current().is_some() {
+        failure!("File exits: {}", BUILD_JSON);
+        return;
     }
 
     let mut java_version = "";
@@ -63,8 +50,8 @@ pub fn create_build_json(args: &Vec<String>) {
             builder_version = &arg.as_str()[8..];
         }
     }
-    if java_version == "" || builder == "" || builder_version == "" {
-        print_message(MessageType::ERROR, "Args java version, builder or builder version is not assigned or format error.");
+    if java_version.is_empty() || builder.is_empty() || builder_version.is_empty() {
+        failure!("Args java version, builder or builder version is not assigned or format error.");
         return;
     }
     let mut build_json_object = object!{
@@ -75,41 +62,33 @@ pub fn create_build_json(args: &Vec<String>) {
         },
     };
     match get_archive_version("me.hatter", "commons") {
-        Err(err) => print_message(MessageType::ERROR, &format!("Get me.hatter:commons version failed: {}", err)),
+        Err(err) => failure!("Get me.hatter:commons version failed: {}", err),
         Ok(ver) => build_json_object["repo"] = object! {
             "dependencies" => array! [
                 format!("me.hatter:commons:{}", ver).as_str()
             ]
         },
-    };
+    }
     match fs::write(BUILD_JSON, json::stringify_pretty(build_json_object, 4)) {
-        Ok(_) => {
-            print_message(MessageType::OK, &format!("Write file success: {}", BUILD_JSON));
-        },
-        Err(err) => {
-            print_message(MessageType::ERROR, &format!("Write file failed: {}, error message: {}", BUILD_JSON, err));
-        },
-    };
+        Ok(_) => success!("Write file success: {}", BUILD_JSON),
+        Err(err) => failure!("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 path_build_json = Path::new(p_build_json);
-    if path_build_json.exists() {
-        Some(p_build_json.to_string())
-    } else {
-        None
-    }
+    let p_build_json = format!("{}/{}", path.to_str()?, BUILD_JSON);
+    let path_build_json = Path::new(&p_build_json);
+    iff!(path_build_json.exists(), Some(p_build_json), None)
 }
 
 pub fn find_build_json_in_parents() -> Option<String> {
     let mut path = fs::canonicalize(".").ok()?;
-    let mut loop_count = 0usize;
+    let mut loop_count = 0_usize;
     loop {
-        loop_count += 1usize;
-        if loop_count > 100usize {
-            print_message(MessageType::ERROR, "Find build.json loop more than 100 loop!");
+        loop_count += 1_usize;
+        if loop_count > 100_usize {
+            failure!("Find build.json loop more than 100 loop!");
             return None;
         }
 
@@ -117,29 +96,27 @@ pub fn find_build_json_in_parents() -> Option<String> {
         if p == "/" {
             return None;
         }
-        let p_build_json = &format!("{}/{}", p, BUILD_JSON);
-        let path_build_json = Path::new(p_build_json);
+        let p_build_json = format!("{}/{}", 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();
     }
 }
 
 pub fn find_build_json() -> Option<String> {
-    match find_build_json_in_current() {
+    if let Some(p) = find_build_json_in_current() {
+        return Some(p);
+    }
+    match find_build_json_in_parents() {
         Some(p) => {
+            warning!("Cannot find {} in current dir, find: {}", BUILD_JSON, 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));
-                Some(p)
-            },
-            None => {
-                print_message(MessageType::ERROR, &format!("Cannot find {}", BUILD_JSON));
-                None
-            },
+        None => {
+            failure!("Cannot find {}", BUILD_JSON);
+            None
         },
     }
 }

src/http.rs

@@ -1,37 +1,35 @@
-use std::{
-    fs::File,
-};
+use std::fs::File;
+use rust_util::{XResult, util_io};
 
-use rust_util::{
-    util_io::copy_io,
-    util_msg::{
-        print_message,
-        MessageType,
-    },
-    XResult,
-};
-
-use super::misc::VERBOSE;
+use crate::misc::VERBOSE;
 
 pub fn download_url(url: &str, dest: &mut File) -> XResult<()> {
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Start download URL: {}", url));
+        debugging!("Start download URL: {}", url);
     }
-    let mut response = reqwest::get(url)?;
+    let mut response = reqwest::blocking::get(url)?;
     let header_content_length: i64 = match response.headers().get("content-length") {
-        None => -1,
-        Some(len_value) => len_value.to_str().unwrap().parse::<i64>().unwrap(),
+        None => -1_i64, Some(len_value) => {
+            let len_str = len_value.to_str().unwrap_or_else(|err| {
+                warning!("Get content length for {:?}, error: {}", len_value, err);
+                "-1"
+            });
+            len_str.parse::<i64>().unwrap_or_else(|err| {
+                warning!("Get content length for {:?}, error: {}", len_value, err);
+                -1
+            })
+        },
     };
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Content-Length: {}", header_content_length));
+        debugging!("Content-Length: {}", header_content_length);
     }
-    copy_io(&mut response, dest, header_content_length)?;
+    util_io::copy_io_default(&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));
+        debugging!("Get URL: {}", url);
     }
-    Ok(reqwest::get(url)?.text()?)
+    Ok(reqwest::blocking::get(url)?.text()?)
 }

src/jdk.rs

@@ -1,21 +1,8 @@
-use std::{
-    collections::HashMap,
-    env,
-    fs,
-    str,
-    path::Path,
-    process::Command,
-};
-
-use super::{
-    rust_util::{
-        util_os::*,
-        util_msg::*,
-    },
-    local_util,
-    tool,
-    misc::*,
-};
+use std::{collections::HashMap, env, fs, str, path::Path, process::Command};
+use rust_util::util_os;
+use rust_util::util_env;
+use crate::{local_util, tool, misc::VERBOSE};
+use plist::Value;
 
 const PATH: &str = "PATH";
 const JAVA_HOME: &str = "JAVA_HOME";
@@ -37,23 +24,19 @@ pub fn get_java_home(version: &str) -> Option<String> {
         Some(j) => Some(j),
         None => match get_local_java_home(version) {
             Some(j) => Some(j),
-            None => if get_cloud_java(version) {
-                get_local_java_home(version)
-            } else {
-                None
-            },
+            None => iff!(get_cloud_java(version), get_local_java_home(version), None),
         },
     }
 }
 
 pub fn get_cloud_java(version: &str) -> bool {
-    if ! is_macos_or_linux() {
+    if !util_os::is_macos_or_linux() {
         return false;
     }
     let cloud_java_names = match &*BUILDJ_JAVA_NAME {
-        None => if is_macos() {
+        None => if util_os::is_macos() {
             vec![OPENJDK_MACOS]
-        } else if is_linux() {
+        } else if util_os::is_linux() {
             vec![JDK_LINUX, OPENJDK_LINUX]
         } else {
             vec![]
@@ -61,85 +44,98 @@ pub fn get_cloud_java(version: &str) -> bool {
         Some(buildj_java_name) => vec![buildj_java_name.as_str()],
     };
     let local_java_home_base_dir = match local_util::get_user_home_dir(LOCAL_JAVA_HOME_BASE_DIR) {
-        Err(_) => return false,
         Ok(o) => o,
+        Err(_) => return false,
     };
     for cloud_java_name in cloud_java_names {
         if tool::get_and_extract_tool_package(&local_java_home_base_dir, false, cloud_java_name, version, false).is_ok() {
             return true;
         }
     }
-    print_message(MessageType::ERROR, &format!("Get java failed, version: {}", version));
+    failure!("Get java failed, version: {}", version);
     false
 }
 
 pub fn get_macos_java_home(version: &str) -> Option<String> {
-    if ! is_macos() {
+    if !util_os::is_macos() || util_env::is_env_on("SKIP_CHECK_JAVA_HOME") {
         return None;
     }
-    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));
-    }
-    if output_in_utf8.contains("Unable to find any JVMs") {
-        None
-    } else {
-        Some(str::from_utf8(&output.stdout).ok()?.trim().to_string())
+    let java_home_x = Command::new(MACOS_LIBEXEC_JAVAHOME).arg("-x").output().ok()?;
+    let java_home_plist_value = match Value::from_reader_xml(&*java_home_x.stdout) {
+        Err(e) => {
+            debugging!("Parse java_home outputs failed: {}", e);
+            return None;
+        }
+        Ok(val) => val,
+    };
+    let java_home_plist_value_array = match java_home_plist_value.as_array() {
+        None => {
+            debugging!("Covert java_home plist output to array failed: {:?}", java_home_plist_value);
+            return None;
+        }
+        Some(val) => val,
+    };
+    for java_home_plist_item in java_home_plist_value_array {
+        debugging!("Checking: {:?}", java_home_plist_item);
+        if let Some(jvm_item) = java_home_plist_item.as_dictionary() {
+            let jvm_version_value = jvm_item.get("JVMVersion");
+            let jvm_home_path_value = jvm_item.get("JVMHomePath");
+            if let (Some(Value::String(jvm_version)), Some(Value::String(jvm_path))) = (jvm_version_value, jvm_home_path_value) {
+                debugging!("Check version: {} vs {}", jvm_version, version);
+                if jvm_version.starts_with(version) {
+                    debugging!("Check version success: {} -> {}", jvm_version, jvm_path);
+                    return Some(jvm_path.into());
+                }
+            }
+        }
     }
+    None
 }
 
 pub fn get_local_java_home(version: &str) -> Option<String> {
     let local_java_home_base_dir = local_util::get_user_home_dir(LOCAL_JAVA_HOME_BASE_DIR).ok()?;
     let paths = fs::read_dir(Path::new(&local_java_home_base_dir)).ok()?;
     for path in paths {
-        match path {
-            Err(_) => (),
-            Ok(dir_entry) => match dir_entry.path().to_str() {
-                None => (),
-                Some(p) => {
+        if let Ok(dir_entry) = path {
+            if let Some(p) = dir_entry.path().to_str() {
+                if *VERBOSE {
+                    debugging!("Try match path: {}", p);
+                }
+                let mut path_name = p;
+                if p.ends_with('/') {
+                    path_name = &path_name[..path_name.len() - 1]
+                }
+                if let Some(i) = path_name.rfind('/') {
+                    path_name = &path_name[i + 1..];
+                }
+                let matched_path_opt = if (path_name.starts_with("jdk-") && (&path_name[4..]).starts_with(version))
+                    || (path_name.starts_with("jdk") && (&path_name[3..]).starts_with(version)) {
+                    Some(p)
+                } else {
+                    None
+                };
+                if let Some(matched_path) = matched_path_opt {
                     if *VERBOSE {
-                        print_message(MessageType::DEBUG, &format!("Try match path: {}", p));
+                        debugging!("Matched JDK path found: {}", matched_path);
                     }
-                    let mut path_name = p;
-                    if p.ends_with("/") {
-                        path_name = &path_name[..path_name.len() - 1]
-                    }
-                    let last_index_of_slash = path_name.rfind('/');
-                    match last_index_of_slash {
-                        None => (),
-                        Some(i) => path_name = &path_name[i+1..],
+                    return if local_util::is_path_exists(matched_path, "Contents/Home") {
+                        Some(format!("{}/{}", matched_path, "Contents/Home"))
+                    } else {
+                        Some(matched_path.to_string())
                     };
-                    let mut matched_path = "";
-                    if path_name.starts_with("jdk-") && (&path_name[4..]).starts_with(version) {
-                        matched_path = p;
-                    } else if path_name.starts_with("jdk") && (&path_name[3..]).starts_with(version) {
-                        matched_path = p;
-                    }
-                    if matched_path != "" {
-                        if *VERBOSE {
-                            print_message(MessageType::DEBUG, &format!("Matched JDK path found: {}", matched_path));
-                        }
-                        if local_util::is_path_exists(matched_path, "Contents/Home") {
-                            return Some(format!("{}/{}", matched_path, "Contents/Home"));
-                        } else {
-                            return Some(matched_path.to_string());
-                        }
-                    }
-                },
-            },
-        };
+                }
+            }
+        }
     }
     None
 }
 
 pub fn extract_jdk_and_wait(file_name: &str) {
-    match local_util::get_user_home_dir(LOCAL_JAVA_HOME_BASE_DIR) {
-        Err(_) => (),
-        Ok(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));
-        }),
-    };
+    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| {
+            failure!("Extract file: {}, failed: {}", file_name, err);
+        });
+    }
 }
 
 pub fn get_env() -> HashMap<String, String> {

src/local_util.rs

@@ -1,49 +1,25 @@
-use std::{
-    env,
-    fs::{self, File},
-    io::{Read, ErrorKind},
-    path::Path,
-    process::Command,
-    time::SystemTime,
-};
-
-use rust_util::{
-    XResult,
-    new_box_ioerror,
-    util_msg::{
-        print_message,
-        MessageType,
-    },
-    util_io::*,
-};
-
-use crypto::{
-    digest::Digest,
-    md5::Md5,
-    sha1::Sha1,
-    sha2::{Sha256, Sha512},
-};
+use std::env;
+use std::path::Path;
+use std::process::Command;
+use std::fs::{self, File};
+use std::io::{Read, ErrorKind};
+use rust_util::XResult;
+use rust_util::util_io::{self, DEFAULT_BUF_SIZE, PrintStatusContext};
+use crypto::{digest::Digest, md5::Md5, sha1::Sha1, sha2::{Sha256, Sha512}};
 
 pub fn get_args_as_vec() -> Vec<String> {
-    let mut args_vec:Vec<String> = vec![];
-    for arg in env::args() {
-        args_vec.push(arg);
-    }
-    args_vec
+    env::args().collect::<Vec<String>>()
 }
 
-pub fn is_buildin_args(args: &Vec<String>) -> bool {
-    if args.len() <= 1 {
-        false
-    } else {
-        args.get(1).unwrap().starts_with(":::")
-        || args.get(1).unwrap().starts_with("...")
-    }
+pub fn is_buildin_args(args: &[String]) -> bool {
+    args.get(1)
+        .map(|arg| arg.starts_with(":::") || arg.starts_with("..."))
+        .unwrap_or(false)
 }
 
 pub fn verify_file_integrity(integrity: &str, file_name: &str) -> XResult<bool> {
     match integrity.find('-') {
-        None => Err(new_box_ioerror(&format!("Not supported integrigty: {}", integrity))),
+        None => simple_error!("Not supported integrigty: {}", integrity),
         Some(index) => {
             let digest_hex = &integrity[index+1..];
             let calc_digest_hex = match &integrity[0..index] {
@@ -51,11 +27,11 @@ pub fn verify_file_integrity(integrity: &str, file_name: &str) -> XResult<bool>
                 "sha512:hex" => calc_file_digest(&mut Sha512::new(), "SHA512", file_name)?,
                 "sha1:hex" => calc_file_digest(&mut Sha1::new(), "SHA1", file_name)?,
                 "md5:hex" => calc_file_digest(&mut Md5::new(), "MD5", file_name)?,
-                _ => return Err(new_box_ioerror(&format!("Not supported integrigty: {}", integrity))),
+                _ => return simple_error!("Not supported integrigty: {}", integrity),
             };
             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));
+                failure!("Verify integrity failed, expected: {}, actual: {}", digest_hex, calc_digest_hex);
             }
             Ok(integrity_verify_result)
         },
@@ -69,14 +45,11 @@ pub fn calc_sha256(d: &[u8]) -> String {
 }
 
 pub fn calc_file_digest(digest: &mut dyn Digest, digest_alg: &str, file_name: &str) -> XResult<String> {
-    let mut buf: [u8; DEFAULT_BUF_SIZE] = [0u8; DEFAULT_BUF_SIZE];
+    let mut buf = [0u8; DEFAULT_BUF_SIZE];
     let mut f = File::open(file_name)?;
-    let file_len = match f.metadata() {
-        Err(_) => -1i64,
-        Ok(meta_data) => meta_data.len() as i64,
-    };
-    let start = SystemTime::now();
-    let mut written = 0i64;
+    let file_len = f.metadata().map(|md| md.len() as i64).unwrap_or(-1_i64);
+    let mut print_status_context = PrintStatusContext::default();
+    let mut written = 0_i64;
     loop {
         let len = match f.read(&mut buf) {
             Ok(0) => { println!(); return Ok(digest.result_str()); },
@@ -86,18 +59,17 @@ pub fn calc_file_digest(digest: &mut dyn Digest, digest_alg: &str, file_name: &s
         };
         digest.input(&buf[..len]);
         written += len as i64;
-        let cost = SystemTime::now().duration_since(start.clone()).unwrap();
-        print_status_last_line(&format!("Calc {}", digest_alg), file_len, written, cost);
+        util_io::print_status_last_line(&format!("Calc {}", digest_alg), file_len, written, &mut print_status_context);
     }
 }
 
 pub fn get_user_home() -> XResult<String> {
-   match dirs::home_dir() {
-        None => Err(new_box_ioerror("Home dir not found!")),
+    match dirs::home_dir() {
         Some(home_dir_o) => match home_dir_o.to_str() {
-            None => Err(new_box_ioerror("Home dir not found!")),
             Some(home_dir_str) => Ok(home_dir_str.to_string()),
+            None => simple_error!("Home dir not found!"),
         },
+        None => simple_error!("Home dir not found!"),
     }
 }
 
@@ -123,23 +95,22 @@ pub fn extract_package_and_wait(dir: &str, file_name: &str) -> XResult<()> {
         cmd = Command::new("tar");
         cmd.arg("-xzvf");
     } else {
-        return Err(new_box_ioerror(&format!("Unknown file type: {}", file_name)));
+        return simple_error!("Unknown file type: {}", file_name);
     }
     cmd.arg(file_name).current_dir(dir).spawn()?.wait()?;
     Ok(())
 }
 
 pub fn init_home_dir(home_sub_dir: &str) {
-    match get_user_home_dir(home_sub_dir) {
-        Err(_) => (),
-        Ok(user_home_dir) => init_dir(&user_home_dir),
-    };
+    if let Ok(user_home_dir) = get_user_home_dir(home_sub_dir) {
+        init_dir(&user_home_dir);
+    }
 }
 
 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));
+            failure!("Init dir {} failed: {}", dir, err);
         });
     }
 }

src/main.rs

@@ -1,12 +1,10 @@
-#[macro_use]
-extern crate json;
-#[macro_use]
-extern crate lazy_static;
-extern crate term;
-extern crate dirs;
-extern crate crypto;
-extern crate urlencoding;
-extern crate rust_util;
+#[macro_use] extern crate json;
+#[macro_use] extern crate lazy_static;
+#[macro_use] extern crate rust_util;
+
+use std::fs;
+use std::collections::HashMap;
+use std::process::{self, Command};
 
 pub mod jdk;
 pub mod local_util;
@@ -15,89 +13,84 @@ pub mod tool;
 pub mod build_json;
 pub mod misc;
 
-use std::{
-    collections::HashMap,
-    fs,
-    process::Command,
-};
-
-use rust_util::{
-    util_msg::{
-        print_message,
-        MessageType,
-    },
-    util_cmd::run_command_and_wait,
-};
+use rust_util::util_cmd;
 use tool::*;
 use jdk::*;
 use build_json::*;
 use misc::*;
 
-const BUILDJ: &str = "buildj";
-const BUDERJ_VER: &str = env!("CARGO_PKG_VERSION");
-const GIT_HASH: &str = env!("GIT_HASH");
-const BUILD_DATE: &str = env!("BUILD_DATE");
 
-
-fn do_with_buildin_arg_java(first_arg: &str, args: &Vec<String>) {
-    let ver = &first_arg[7..];
-    if ver == "" {
-        print_message(MessageType::ERROR, &format!("Java version is not assigned!"));
-        return;
-    }
+fn do_with_buildin_arg_java_cmd(first_arg: &str, args: &[String]) {
+    let first_num_pos = first_arg.chars().position(|c| c >= '0' && c <= '9');
+    let (cmd, ver) = match first_num_pos {
+        None => {
+            failure!("Java command version is not assigned!");
+            return;
+        },
+        Some(pos) => {
+            (&first_arg[3..pos], &first_arg[pos..])
+        },
+    };
     match get_java_home(ver) {
-        None => print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", ver)),
+        None => failure!("Assigned java version not found: {}", ver),
         Some(java_home) => {
-            print_message(MessageType::OK, &format!("Find java home: {}", java_home));
-            let java_bin = &format!("{}/bin/java", java_home);
+            success!("Find java home: {}", java_home);
+            let java_bin = &format!("{}/bin/{}", java_home, cmd);
+            if fs::metadata(java_bin).is_ok() {
+                success!("Command found: {}", java_bin);
+            } else {
+                failure!("Command {} not exists", java_bin);
+                return;
+            }
             let mut cmd = Command::new(java_bin);
             cmd.envs(&get_env_with_java_home(&java_home));
             if args.len() > 2 {
                 cmd.args(&args[2..]);
             }
-            run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-                print_message(MessageType::ERROR, &format!("Exec java failed: {}", err));
-            });
+            if let Err(err) = util_cmd::run_command_and_wait(&mut cmd) {
+                failure!("Exec java failed: {}", err);
+            }
         },
     };
 }
 
-fn do_with_buildin_arg_maven(first_arg: &str, args: &Vec<String>) {
+fn do_with_buildin_arg_maven(first_arg: &str, args: &[String]) {
     do_with_buildin_arg_builder(first_arg, args, "maven")
 }
 
-fn do_with_buildin_arg_gradle(first_arg: &str, args: &Vec<String>) {
+fn do_with_buildin_arg_gradle(first_arg: &str, args: &[String]) {
     do_with_buildin_arg_builder(first_arg, args, "gradle")
 }
 
-fn do_with_buildin_arg_config(_first_arg: &str, args: &Vec<String>) {
+fn do_with_buildin_arg_config(_first_arg: &str, args: &[String]) {
+    information!("Current config file: ~/{}", tool::STANDARD_CONFIG_JSON);
     if args.len() <= 2 {
-        print_message(MessageType::ERROR, "No arguments, get or set.");
+        failure!("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."),
-            Ok(secret) => print_message(MessageType::OK, &format!("Config secret: {}", secret)),
+            Err(_) => warning!("No config found."),
+            Ok(secret) => success!("Config secret: {}", secret),
         },
         "set" => {
             if args.len() < 4 {
-                print_message(MessageType::ERROR, "Need secret for set, :::config set <secret>");
+                failure!("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)),
-                    Ok(_) => print_message(MessageType::OK, "Config secret success."),
+                    Err(err) => failure!("Config secret failed: {}", err),
+                    Ok(_) => success!("Config secret success."),
                 }
             }
         },
-        arg => print_message(MessageType::ERROR, &format!("Unknown argument: {}", arg))
+        arg => failure!("Unknown argument: {}", arg)
     }
 }
 
-fn do_with_buildin_arg_builder(first_arg: &str, args: &Vec<String>, builder_name: &str) {
+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 == "" {
-        print_message(MessageType::ERROR, &format!("Builder version is not assigned!"));
+    if builder_version.is_empty() {
+        failure!("Builder version is not assigned!");
         return;
     }
     let mut has_java = false;
@@ -105,56 +98,49 @@ fn do_with_buildin_arg_builder(first_arg: &str, args: &Vec<String>, builder_name
     if args.len() > 2 && args[2].starts_with("--java") {
         has_java = true;
         let java_version = &args[2][6..];
-        if java_version != "" {
+        if !java_version.is_empty() {
             java_home = match get_java_home(java_version) {
-                None => {
-                    print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", java_version));
+                Some(h) => h, None => {
+                    failure!("Assigned java version not found: {}", java_version);
                     return;
                 },
-                Some(h) => h,
             };
         }
     }
     let builder_desc = match tool::get_builder_home(builder_name, builder_version) {
-        None => {
-            print_message(MessageType::ERROR, &format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
+        Some(h) => h, None => {
+            failure!("Assigned builder: {}, version: {} not found.", builder_name, builder_version);
             return;
         },
-        Some(h) => h,
     };
     if has_java {
-        print_message(MessageType::OK, &format!("JAVA_HOME    = {}", java_home));
+        success!("JAVA_HOME    = {}", java_home);
     }
-    print_message(MessageType::OK, &format!("BUILDER_HOME = {}", &builder_desc.home));
+    success!("BUILDER_HOME = {}", &builder_desc.home);
 
-    let mut new_env = if has_java {
-        get_env_with_java_home(&java_home)
-    } else {
-        get_env()
-    };
+    let mut new_env = iff!(has_java, get_env_with_java_home(&java_home), 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 = match has_java { true => 3, false => 2 };
-    for i in from_index..args.len() {
-        cmd.arg(&args[i]);
+    let from_index = iff!(has_java, 3, 2);
+    for arg in args.iter().skip(from_index) {
+        cmd.arg(&arg);
+    }
+    if let Err(err) = util_cmd::run_command_and_wait(&mut cmd) {
+        failure!("Run build command failed: {}", err);
     }
-    run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run build command failed: {}", err));
-    });
 }
 
-fn do_with_buildin_arg_ddd(first_arg: &str, args: &Vec<String>) {
+fn do_with_buildin_arg_ddd(first_arg: &str, args: &[String]) {
     let build_json_object = match read_build_json_object() {
-        None => return,
-        Some(object) => object,
+        Some(object) => object, None => return,
     };
     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..]));
+        failure!("Cannot find build.json#xRuns#{}", &first_arg[3..]);
         return;
     }
     let cmd_name = build_json_object_xrun[0].to_string();
@@ -167,40 +153,45 @@ fn do_with_buildin_arg_ddd(first_arg: &str, args: &Vec<String>) {
         }
         cmd.arg(build_json_object_xrun[i].to_string());
     }
-    for i in 3..args.len() {
+    for arg in args.iter().skip(3) {
         if *VERBOSE {
-            cmd_args.push(args[i].to_string());
+            cmd_args.push(arg.to_string());
         }
-        cmd.arg(args[i].to_string());
+        cmd.arg(arg.to_string());
     }
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Running cmd: {}, args: {:?}", &cmd_name, cmd_args));
+        debugging!("Running cmd: {}, args: {:?}", &cmd_name, cmd_args);
+    }
+    if let Err(err) = util_cmd::run_command_and_wait(&mut cmd) {
+        failure!("Run xRun command failed: {}", err);
     }
-    run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run xRun command failed: {}", err));
-    });
 }
 
-fn do_with_buildin_args(args: &Vec<String>) {
-     let first_arg = args.get(1).unwrap();
-    if first_arg == ":::" || first_arg == ":::help" {
-        print_usage();
-    } else if first_arg == ":::version" {
-        print_version();
-    } else if first_arg == ":::create" {
-        create_build_json(&args);
-    } else if first_arg == ":::config" {
-        do_with_buildin_arg_config(first_arg, args);
-    } else if first_arg.starts_with(":::java") {
-        do_with_buildin_arg_java(first_arg, args);
-    } else if first_arg.starts_with(":::maven") {
-        do_with_buildin_arg_maven(first_arg, args);
-    } else if first_arg.starts_with(":::gradle") {
-        do_with_buildin_arg_gradle(first_arg, args);
-    } else if first_arg.starts_with("...") {
-        do_with_buildin_arg_ddd(first_arg, args);
-    } else {
-        print_message(MessageType::ERROR, &format!("Unknown args: {:?}", &args));
+fn do_with_buildin_args(args: &[String]) {
+    let first_arg = args.get(1).unwrap();
+    match first_arg.as_str() {
+        ":::" | ":::help" => print_usage(),
+        ":::version"      => print_version(),
+        ":::create"       => create_build_json(args),
+        ":::config"       => do_with_buildin_arg_config(first_arg, args),
+        a if a.starts_with(":::jar")    => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::java")   => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jinfo")  => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jlink")  => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::keytool")=> do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jaotc")  => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jcmd")   => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jconsole")=> do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jdb")    => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jmap")   => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jps")    => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jstack") => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jstat")  => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::jimage") => do_with_buildin_arg_java_cmd(a, args),
+        a if a.starts_with(":::maven")  => do_with_buildin_arg_maven   (a, args),
+        a if a.starts_with(":::gradle") => do_with_buildin_arg_gradle  (a, args),
+        a if a.starts_with("...")       => do_with_buildin_arg_ddd     (a, args),
+        _ => failure!("Unknown args: {:?}", &args),
     }
 }
 
@@ -210,40 +201,38 @@ 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!");
+        failure!("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!");
+        failure!("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_message(MessageType::DEBUG, &format!("Builder name: {}", builder_name));
-        print_message(MessageType::DEBUG, &format!("Builder version: {}", builder_version));
+        debugging!("Java version: {}", java_version);
+        debugging!("Builder name: {}", builder_name);
+        debugging!("Builder version: {}", builder_version);
     }
 
     let java_home = match get_java_home(java_version) {
-        None => {
-            print_message(MessageType::ERROR, &format!("Assigned java version not found: {}", java_version));
+        Some(h) => h, None => {
+            failure!("Assigned java version not found: {}", java_version);
             return None;
         },
-        Some(h) => h,
     };
     let builder_desc = match tool::get_builder_home(builder_name, builder_version) {
-        None => {
-            print_message(MessageType::ERROR, &format!("Assigned builder: {}, version: {} not found.", builder_name, builder_version));
+        Some(h) => h, None => {
+            failure!("Assigned builder: {}, version: {} not found.", builder_name, builder_version);
             return None;
         },
-        Some(h) => h,
     };
     Some((java_home, builder_desc))
 }
 
-fn get_final_args(args: &Vec<String>, build_json_object: &json::JsonValue) -> Option<Vec<String>> {
+fn get_final_args(args: &[String], build_json_object: &json::JsonValue) -> Option<Vec<String>> {
     let mut final_args:Vec<String> = vec![];
     if args.len() > 1 {
         let arg1 = &args[1];
@@ -251,9 +240,9 @@ fn get_final_args(args: &Vec<String>, build_json_object: &json::JsonValue) -> Op
             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));
+                warning!("xArgs argument not found: {}", a_cmd);
                 if args.len() == 2 {
-                    print_message(MessageType::ERROR, "Only one xArgs argument, exit.");
+                    failure!("Only one xArgs argument, exit.");
                     return None;
                 }
                 final_args.push(arg1.to_string());
@@ -269,8 +258,8 @@ fn get_final_args(args: &Vec<String>, build_json_object: &json::JsonValue) -> Op
         }
     }
     if args.len() > 2 {
-        for i in 2..args.len() {
-            final_args.push(args[i].to_string());
+        for arg in args.iter().skip(2) {
+            final_args.push(arg.to_string());
         }
     }
     Some(final_args)
@@ -281,14 +270,12 @@ 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));
+                debugging!("Env: {}", env);
             }
-            let env_k = &env[0];
-            let env_v = &env[1];
-            if env_k.is_null() || env_v.is_null() {
-                continue;
+            let (env_k, env_v) = (&env[0], &env[1]);
+            if let (Some(env_k_str), Some(env_v_str)) = (env_k.as_str(), env_v.as_str()) {
+                the_env.insert(env_k_str.to_owned(), env_v_str.to_owned());
             }
-            the_env.insert(env_k.as_str().unwrap().to_string(), env_v.as_str().unwrap().to_string());
         }
     }
 }
@@ -312,13 +299,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));
+                warning!("Unknown builder: {}", builder_version);
             }
         }
         if *VERBOSE {
-            print_message(MessageType::DEBUG, &format!("Use env configed build.json: {}",  json::stringify(build_json_object.clone())));
+            debugging!("Use env configed build.json: {}",  json::stringify(build_json_object.clone()));
         }
-        print_message(MessageType::OK, "Find build.json @ENV");
+        success!("Find build.json @ENV");
         Some(build_json_object)
     } else {
         None
@@ -326,70 +313,63 @@ fn read_build_json_object_from_env() -> Option<json::JsonValue> {
 }
 
 fn read_build_json_object() -> Option<json::JsonValue> {
-    match read_build_json_object_from_env() {
-        Some(o) => return Some(o),
-        None => (),
-    };
-
-    let build_json = match find_build_json() {
-        None => return None,
-        Some(p) => p,
-    };
-
-    print_message(MessageType::OK, &format!("Find {} @ {}", BUILD_JSON, build_json));
-    let build_json_content = match fs::read_to_string(build_json) {
-        Err(err) => {
-            print_message(MessageType::ERROR, &format!("Read {} failed: {}", BUILD_JSON, err));
-            return None;
-        },
-        Ok(content) => content,
-    };
-    match json::parse(&build_json_content) {
-        Err(err) => {
-            print_message(MessageType::ERROR, &format!("Parse JSON failed: {}", err));
-            None
-        },
-        Ok(object) => Some(object),
+    if let Some(o) = read_build_json_object_from_env() {
+        return Some(o);
     }
+
+    let build_json = find_build_json()?;
+    success!("Find {} @ {}", BUILD_JSON, build_json);
+
+    let build_json_content = fs::read_to_string(build_json).map_err(|err| {
+        failure!("Read {} failed: {}", BUILD_JSON, err);
+        err
+    }).ok()?;
+    json::parse(&build_json_content).map_err(|err| {
+        failure!("Parse JSON failed: {}", err);
+        err
+    }).ok()
 }
 
 
 fn main() {
-    print_message(MessageType::INFO, &format!("{} - version {} - {}", BUILDJ, BUDERJ_VER, &GIT_HASH[0..7]));
+    match get_short_git_hash() {
+        None => information!("{} - version {}", BUILDJ, BUDERJ_VER),
+        Some(shot_git_hash) => information!("{} - version {} - {}", BUILDJ, BUDERJ_VER, &shot_git_hash),
+    }
 
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Full GIT_HASH: {}", GIT_HASH));
-        print_message(MessageType::DEBUG, &format!("Build date: {}", BUILD_DATE));
+        if let Some(full_git_hash) = get_full_git_hash() {
+            debugging!("Full GIT_HASH: {}", full_git_hash);
+        }
+        debugging!("Build date: {}", BUILD_DATE);
     }
 
     let args = local_util::get_args_as_vec();
-    print_message(MessageType::INFO, &format!("Arguments: {:?}", args));
+    information!("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));
+        debugging!("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));
+        debugging!("Init home dir: {}", jdk::LOCAL_JAVA_HOME_BASE_DIR);
     }
     local_util::init_home_dir(jdk::LOCAL_JAVA_HOME_BASE_DIR);
 
     let build_json_object = match read_build_json_object() {
-        None => return,
-        Some(object) => object,
+        Some(object) => object, None => return,
     };
 
     let (java_home, builder_desc) = match get_java_and_builder(&build_json_object) {
-        None => return,
-        Some((java_home, builder_desc)) => (java_home, builder_desc),
+        Some((java_home, builder_desc)) => (java_home, builder_desc), None => return,
     };
    
-    print_message(MessageType::OK, &format!("JAVA_HOME    = {}", java_home));
-    print_message(MessageType::OK, &format!("BUILDER_HOME = {}", &builder_desc.home));
+    success!("JAVA_HOME    = {}", java_home);
+    success!("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() {
@@ -401,23 +381,29 @@ fn main() {
     cmd.envs(&new_env);
 
     let final_args = match get_final_args(&args, &build_json_object) {
-        None => return,
-        Some(fa) => fa,
+        Some(fa) => fa, None => return,
     };
     if *VERBOSE {
-        print_message(MessageType::DEBUG, &format!("Final arguments: {:?}", &final_args));
+        debugging!("Final arguments: {:?}", &final_args);
     }
     for f_arg in final_args {
         cmd.arg(f_arg);
     }
     if *VERBOSE {
-        print_message(MessageType::DEBUG, "-----BEGIN ENVIRONMENT VARIABLES-----");
+        debugging!("-----BEGIN ENVIRONMENT VARIABLES-----");
         for (k, v) in new_env {
-            print_message(MessageType::DEBUG, &format!("{}={}", k, v));
+            debugging!("{}={}", k, v);
         }
-        print_message(MessageType::DEBUG, "-----END ENVIRONMENT VARIABLES-----");
+        debugging!("-----END ENVIRONMENT VARIABLES-----");
     }
-    run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
-        print_message(MessageType::ERROR, &format!("Run build command failed: {}", err));
+    let exit_status = util_cmd::run_command_and_wait(&mut cmd).unwrap_or_else(|err| {
+        failure!("Run build command failed: {}", err);
+        process::exit(-1);
     });
+
+    if !exit_status.success() {
+        if let Some(exit_code) = exit_status.code() {
+            process::exit(exit_code);
+        }
+    }
 }

src/misc.rs

@@ -1,48 +1,48 @@
-
 use std::env;
-use rust_util::util_env::*;
+use rust_util::{util_env, util_term};
+
+pub const BUILDJ:     &str = "buildj";
+pub const BUDERJ_VER: &str = env!("CARGO_PKG_VERSION");
+pub const BUILD_DATE: &str = env!("BUILD_DATE");
+const     GIT_HASH:   &str = env!("GIT_HASH");
+
 
 lazy_static! {
-    pub static ref VERBOSE: bool = is_env_on("BUILDJ_VERBOSE");
-    pub static ref NOAUTH: bool = is_env_on("BUILDJ_NOAUTH");
-    pub static ref NOBUILDIN: bool = is_env_on("BUILDJ_NOBUILDIN");
-    pub static ref AUTH_TOKEN: Option<String> = env::var("BUILDJ_AUTH_TOKEN").ok();
-    pub static ref JAVA_VERSION: Option<String> = env::var("BUILDJ_JAVA").ok();
+    pub static ref VERBOSE: bool   = util_env::is_env_on("BUILDJ_VERBOSE");
+    pub static ref NOAUTH: bool    = util_env::is_env_on("BUILDJ_NOAUTH");
+    pub static ref NOBUILDIN: bool = util_env::is_env_on("BUILDJ_NOBUILDIN");
+    pub static ref AUTH_TOKEN: Option<String>      = env::var("BUILDJ_AUTH_TOKEN").ok();
+    pub static ref JAVA_VERSION: Option<String>    = env::var("BUILDJ_JAVA").ok();
     pub static ref BUILDER_VERSION: Option<String> = env::var("BUILDJ_BUILDER").ok();
+    pub static ref BUILD_YEAR: String              = env::var("BUILD_YEAR").unwrap_or_else(|_| "unknown".to_string());
 }
 
 pub fn print_usage() {
-    print!(r#"
-buildj :::                                          - print this message
-buildj :::help                                      - print this message
-buildj :::version                                   - print version
-buildj :::config get|set <secret>                   - get/set config
-buildj :::create --java<version> --maven<version>   - create java + maven project
-  e.g. buildj :::create --java1.8 --maven3.5.2
-buildj :::create --java<version> --gradle<version>  - create java + gradle project
-  e.g. buildj :::create --java1.8 --gradle3.5.1
-buildj :::java<version> [-version]                  - run java with assigned version
-  e.g. buildj :::java1.8 -version
-buildj :::maven<version> [--java<version>]          - run maven with assigned version and java version
-  e.g. buildj :::maven3.5.2 --java1.8 ARGS
-buildj :::gradle<version> [--java<version>]         - run gradle with assigned version and java version
-  e.g. buildj :::gradle3.5.1 --java1.8 ARGS
-buildj                                              - run build, run assigned version builder tool
-BUILDJ_NOBUILDIN=1 buildj                           - ignore buildj buildin commands
-BUILDJ_VERBOSE=1 buildj                             - run buildj in verbose mode
-BUILDJ_NOAUTH=1 buildj                              - run buildj in no auth mode
-BUILDJ_JAVA_NAME=jdk-name buildj                    - assgin java name, e.g. adoptjdk-linux
-BUILDJ_AUTH_TOKEN=auth-token buildj                 - assign auth token
-BUILDJ_JAVA=1.8 BUILDJ_BUILDER=maven3.5.2 buildj    - direct run buildj
-"#);
+    println!("\n{}", include_str!("usage.txt"));
 }
 
 pub fn print_version() {
-  print!(r#"buildj {} - {}
-Copyright (C) 2019 Hatter Jiang.
-License MIT <https://opensource.org/licenses/MIT>
+  println!(r#"buildj {}{}{}
+Build date: {}
 
-Written by Hatter Jiang
-"#, super::BUDERJ_VER, &super::GIT_HASH[0..7]);
+Copyright (C) 2019-{} Hatter Jiang.
+License MIT <{}https://opensource.org/licenses/MIT{}>
+
+Official website: {}https://buildj.ruststack.org/{}
+"#, BUDERJ_VER,
+           get_short_git_hash().map(|h| format!(" - {}", h)).unwrap_or("".into()),
+           get_full_git_hash().map(|h| format!("\nFull git commit hash: {}{}{}", util_term::BOLD, h, util_term::END)).unwrap_or("".into()),
+           BUILD_DATE,
+           *BUILD_YEAR,
+           util_term::UNDER, util_term::END,
+           util_term::UNDER, util_term::END);
 }
 
+pub fn get_full_git_hash() -> Option<&'static str> {
+    // build from crates, git hash is empty
+    iff!(GIT_HASH.is_empty(), None, Some(GIT_HASH))
+}
+
+pub fn get_short_git_hash() -> Option<&'static str> {
+    get_full_git_hash().map(|h| &h[0..7])
+}

src/tool.rs

@@ -1,29 +1,13 @@
-use std::{
-    fs::{self, File},
-    path::Path,
-};
-
-use super::{
-    http,
-    rust_util::{
-        XResult,
-        new_box_ioerror,
-        util_os::is_macos_or_linux,
-        util_msg::{
-            print_message,
-            MessageType,
-        },
-    },
-    local_util::{self, *},
-    misc::*,
-};
+use std::{fs::{self, File}, path::Path};
+use rust_util::{ XResult, util_os};
+use crate::{http, local_util, misc::{AUTH_TOKEN, VERBOSE, NOAUTH}};
 
 const M2_HOME: &str = "M2_HOME";
 const MAVEN_HOME: &str = "MAVEN_HOME";
 const GRADLE_HOME: &str = "GRADLE_HOME";
 
 pub const LOCAL_BUILDER_HOME_BASE_DIR: &str = ".jssp/builder";
-const STANDARD_CONFIG_JSON: &str = ".standard_config.json";
+pub const STANDARD_CONFIG_JSON: &str = ".standard_config.json";
 const TOOL_PACKAGE_DETAIL_URL: &str = "https://hatter.ink/tool/query_tool_by_name_version.json";
 const TOOL_PACKAGE_DETAIL_URL_WITHOUT_AUTH: &str = "https://hatter.ink/tool/query_tool_by_name_version_without_auth.json";
 
@@ -50,26 +34,23 @@ impl BuilderDesc {
     pub fn get_builder_bin(&self) -> String {
         match &self.bin {
             Some(b) => b.clone(),
-            None => {
-                match self.name {
-                    BuilderName::Maven => format!("{}/bin/mvn", self.home.clone()),
-                    BuilderName::Gradle => format!("{}/bin/gradle", self.home.clone()),
-                }
+            None => match self.name {
+                BuilderName::Maven => format!("{}/bin/mvn", self.home.clone()),
+                BuilderName::Gradle => format!("{}/bin/gradle", self.home.clone()),
             }
         }
     }
 }
 
 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,
+    let local_builder_home_base_dir = match local_util::get_user_home_dir(LOCAL_BUILDER_HOME_BASE_DIR) {
+        Ok(o) => o, Err(_) => return None,
     };
     let builder_name = match builder {
         "maven" => BuilderName::Maven,
         "gradle" => BuilderName::Gradle,
         _ => {
-            print_message(MessageType::ERROR, &format!("Unknown builder: {}", builder));
+            failure!("Unknown builder: {}", builder);
             return None;
         },
     };
@@ -83,90 +64,65 @@ pub fn get_builder_home(builder: &str, version: &str) -> Option<BuilderDesc> {
 }
 
 pub fn get_cloud_builder(builder: &str, version: &str) -> bool {
-    if ! is_macos_or_linux() {
+    if ! util_os::is_macos_or_linux() {
         return false;
     }
     let local_builder_home_base_dir = match local_util::get_user_home_dir(LOCAL_BUILDER_HOME_BASE_DIR) {
-        Err(_) => return false,
-        Ok(o) => o,
+        Ok(o) => o, Err(_) => return false,
     };
     match get_and_extract_tool_package(&local_builder_home_base_dir, true, builder, version, true) {
-        Err(err) => {
-            print_message(MessageType::ERROR, &format!("Get builder: {} failed, version: {}, error: {}", builder, version, err));
-            return false;
+        Ok(_) => true, Err(err) => {
+            failure!("Get builder: {} failed, version: {}, error: {}", builder, version, err);
+            false
         },
-        Ok(_) => true,
     }
 }
 
 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));
-            return None;
-        },
-        Some(p) => {
-            return Some(BuilderDesc{name: builder_name, home: p, bin: None});
+            failure!("Cannot find builder home in: {}", local_builder_home_dir);
+            None
         },
+        Some(p) => Some(BuilderDesc{name: builder_name, home: p, bin: None}),
     }
 }
 
 pub fn get_local_builder_home_sub_first_sub_dir(local_builder_home_dir: &str) -> Option<String> {
     let paths = fs::read_dir(Path::new(&local_builder_home_dir)).ok()?;
     for path in paths {
-        match path {
-            Err(_) => (),
-            Ok(p) => {
-                if p.path().is_dir() {
-                    return Some(p.path().to_str()?.to_string());
-                }
-            },
-        };
+        if let Ok(p) = path {
+            if p.path().is_dir() {
+                return Some(p.path().to_str()?.to_string());
+            }
+        }
     }
     None
 }
 
-pub fn get_extract_dir_name_by_file_name(file_name: &str) -> Option<String> {
-    if file_name != "" {
-        return None;
-    }
-    let mut dir_name = file_name;
-    if file_name.ends_with(".zip") {
-        dir_name = &file_name[..file_name.len()-4];
-    } else if file_name.ends_with(".tgz") {
-        dir_name = &file_name[..file_name.len()-4];
-    } else if file_name.ends_with(".tar.gz") {
-        dir_name = &file_name[..file_name.len()-7];
-    }
-    if dir_name.ends_with("-bin") {
-        dir_name = &dir_name[..dir_name.len()-4];
-    }
-    Some(dir_name.to_string())
-}
-
 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'");
+            debugging!("Use auth token from env 'BUILDJ_AUTH_TOKEN'");
         }
         return Ok((*AUTH_TOKEN).as_ref().unwrap().clone());
     }
 
-    let standard_config_file = get_user_home_dir(STANDARD_CONFIG_JSON)?;
+    let standard_config_file = local_util::get_user_home_dir(STANDARD_CONFIG_JSON)?;
     let standard_config_json = fs::read_to_string(&standard_config_file)?;
     let standard_config_object = json::parse(&standard_config_json)?;
 
     let build_js_auth_token = &standard_config_object["build.js"]["auth_token"];
     
     if build_js_auth_token.is_null() {
-        Err(new_box_ioerror("Standard json#build.js#auth_token is null."))
+        simple_error!("Standard json#build.js#auth_token is null.")
     } else {
         Ok(build_js_auth_token.to_string())
     }
 }
 
 pub fn set_tool_package_secret(secret: &str) -> XResult<()> {
-    let standard_config_file = get_user_home_dir(STANDARD_CONFIG_JSON)?;
+    let standard_config_file = local_util::get_user_home_dir(STANDARD_CONFIG_JSON)?;
 
     match fs::metadata(&standard_config_file) {
         Err(_) => {
@@ -175,12 +131,12 @@ pub fn set_tool_package_secret(secret: &str) -> XResult<()> {
                     "auth_token" => secret, }
                 }, 4)) {
                 Ok(_) => Ok(()),
-                Err(err) => Err(new_box_ioerror(&format!("Write config failed: {}, error message: {}", standard_config_file, err))),
+                Err(err) => simple_error!("Write config failed: {}, error message: {}", standard_config_file, err),
             }
         },
         Ok(f) => {
             if ! f.is_file() {
-                return Err(new_box_ioerror(&format!("Config is not a file: {}", standard_config_file)));
+                return simple_error!("Config is not a file: {}", standard_config_file);
             }
             let standard_config_json = fs::read_to_string(&standard_config_file)?;
             let mut standard_config_object = json::parse(&standard_config_json)?;
@@ -193,7 +149,7 @@ pub fn set_tool_package_secret(secret: &str) -> XResult<()> {
             }
             match fs::write(&standard_config_file, json::stringify_pretty(standard_config_object, 4)) {
                 Ok(_) => Ok(()),
-                Err(err) => Err(new_box_ioerror(&format!("Write config failed: {}, error message: {}", &standard_config_file, err))),
+                Err(err) => simple_error!("Write config failed: {}, error message: {}", &standard_config_file, err),
             }
         }
     }
@@ -201,19 +157,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!");
+        warning!("Running in no auth mode!");
         None
     } else {
         match get_tool_package_secret() {
-            Err(err) => {
-                print_message(MessageType::WARN, &format!("Get package detail secret failed: {}, from file: ~/{}", err, STANDARD_CONFIG_JSON));
+            Ok(r) => Some(r), Err(err) => {
+                warning!("Get package detail secret failed: {}, from file: ~/{}", err, STANDARD_CONFIG_JSON);
                 None
             },
-            Ok(r) => Some(r),
         }
     };
     
-    let mut url = String::new();
+    let mut url = String::with_capacity(1024);
     match secret {
         None => {
             url.push_str(TOOL_PACKAGE_DETAIL_URL_WITHOUT_AUTH);
@@ -230,52 +185,52 @@ 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(http::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)));
+        debugging!("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"])));
+        return simple_error!("Error in get tool package detail: {}", build_json_object["message"]);
     }
     let data = &build_json_object["data"];
     let integrity = &data["integrity"];
     let url = &data["url"];
     let name = &data["name"];
     if integrity.is_null() || url.is_null() || name.is_null() {
-        return Err(new_box_ioerror(&format!("Parse tool package detail failed: {}", tool_package_detail)));
+        return simple_error!("Parse tool package detail failed: {}", tool_package_detail);
     }
     let n = data["n"].to_string();
     let v = data["v"].to_string();
 
-    if extract_match &&  version != &v {
-        return Err(new_box_ioerror(&format!("Required version not match, {}: {} vs {}", name, version, &v)));
+    if extract_match &&  version != v {
+        return simple_error!("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("/");
         target_base_dir.push_str(&format!("{}-{}", n, v));
     }
-    init_dir(&target_base_dir);
+    local_util::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));
+    information!("Start download: {} -> {}", &url.to_string(), &target_file_name);
     http::download_url(&url.to_string(), &mut File::create(&target_file_name)?)?;
 
-    print_message(MessageType::INFO, &format!("Start verify integrity: {} ...", &target_file_name));
+    information!("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.");
+        success!("Verify integrity success.");
     } else {
-        return Err(new_box_ioerror(&format!("Verify integrity failed!")));
+        return simple_error!("Verify integrity failed!");
     }
 
-    print_message(MessageType::INFO, &format!("Start extract file: {}", &target_file_name));
+    success!("Start extract file: {}", &target_file_name);
     local_util::extract_package_and_wait(&target_base_dir, &name.to_string())?;
 
     Ok(true)

src/usage.txt

@@ -0,0 +1,21 @@
+buildj :::                                          - print this message
+buildj :::help                                      - print this message
+buildj :::version                                   - print version
+buildj :::config get|set <secret>                   - get/set config
+buildj :::create --java<version> --maven<version>   - create java + maven project
+  e.g. buildj :::create --java1.8 --maven3.5.2
+buildj :::create --java<version> --gradle<version>  - create java + gradle project
+  e.g. buildj :::create --java1.8 --gradle3.5.1
+buildj :::java<version> [-version]                  - run java with assigned version
+  e.g. buildj :::java1.8 -version
+buildj :::maven<version> [--java<version>]          - run maven with assigned version and java version
+  e.g. buildj :::maven3.5.2 --java1.8 ARGS
+buildj :::gradle<version> [--java<version>]         - run gradle with assigned version and java version
+  e.g. buildj :::gradle3.5.1 --java1.8 ARGS
+buildj                                              - run build, run assigned version builder tool
+BUILDJ_NOBUILDIN=1 buildj                           - ignore buildj buildin commands
+BUILDJ_VERBOSE=1 buildj                             - run buildj in verbose mode
+BUILDJ_NOAUTH=1 buildj                              - run buildj in no auth mode
+BUILDJ_JAVA_NAME=jdk-name buildj                    - assgin java name, e.g. adoptjdk-linux
+BUILDJ_AUTH_TOKEN=auth-token buildj                 - assign auth token
+BUILDJ_JAVA=1.8 BUILDJ_BUILDER=maven3.5.2 buildj    - direct run buildj