Changeset 15310


Ignore:
Timestamp:
2008-04-30T16:47:52+12:00 (14 years ago)
Author:
ak19
Message:

New CheckJavaVersion that works with a default minimum required Java version of 1.4 but which will accept a specific minimum required version as the first cmd-line arg. It still returns 2 if the running Java version is acceptable and 1 if this is lower than the minimum.

Location:
gli/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • gli/trunk/CheckJavaVersion.java

    r10757 r15310  
    1 public class CheckJavaVersion
    2 {
    3     static public void main(String[] args)
    4     {
    5     String java_version = System.getProperty("java.version");
    6     System.out.println("Java version: " + java_version);
     1import java.util.regex.Pattern;
    72
    8     try {
    9         // Identify major version number
    10         int major_dot_position = java_version.indexOf(".");
    11         String java_version_major_string = java_version.substring(0, major_dot_position);
    12         int java_version_major = (new Integer(java_version_major_string)).intValue();
    133
    14         // Identify minor version number
    15         int minor_dot_position = java_version.indexOf(".", major_dot_position + 1);
    16         String java_version_minor_string = java_version.substring(major_dot_position + 1, minor_dot_position);
    17         int java_version_minor = (new Integer(java_version_minor_string)).intValue();
    18 
    19         // Version of Java must be 1.4 or higher to run the GLI
    20         if (java_version_major > 1 || (java_version_major == 1 && java_version_minor >= 4)) {
    21         // Valid
    22         System.exit(2);
    23         }
    24         else {
    25         // Invalid
    26         System.exit(1);
    27         }
     4public class CheckJavaVersion {
     5    static final String MINIMUM_VERSION_PREFIX = "1.4";
     6   
     7    /**
     8     * @param args, arg[0] is the minium version of Java required
     9     * to run the program. arg[1] is the name of the program.
     10     * If arg[1] is left out, then no distinct program name is
     11     * mentioned. If arg[0] is left out as well, then Greenstone3's
     12     * minimum default version of 1.4.x is assumed.
     13     * The program exits with 1 if the Java version being used is
     14     * incompatible and with 2 if it is acceptable.
     15     */
     16    public static void main(String[] args) {
     17        String minimumVersion = MINIMUM_VERSION_PREFIX;
     18        String programName = "this program";
     19        // the version of java that's in use
     20        String runningJavaVersion = System.getProperty("java.version");
     21       
     22        if(args.length > 0) {
     23            minimumVersion = args[0];
     24        }
     25        if(args.length > 1) {
     26            programName = args[1];
     27        }
     28       
     29        System.out.println("\nChecking for a compatible Java version..."
     30                + "\nLooking for minimum version: " + minimumVersion);
     31       
     32        // Version numbers can be of the form "1.5.0_2"
     33        // We want to split version numbers into the individual numbers
     34        // For example: splitting 1.5.0_2 will give us {1,5,0,2},
     35        // while splitting 1.5.0_10 will give us {1,5,0,10}.
     36        // The comparison then is straightforward.
     37       
     38        // We will split version strings into the individual numbers
     39        // using regular expressions. However, the tokens . and _ are
     40        // reserved in regular expressions and need to be escaped:
     41        // Period: \Q.\E;  underscore: \Q_\E.
     42        // Once escaped, it should be indicated in the regular expression
     43        // that the two characters are separate tokens by using |, so
     44        // that the regex becomes: ".|_" -> \Q.\E|\Q_\E.
     45        String period = Pattern.quote(".");
     46        String underscore = Pattern.quote("_");
     47       
     48        String[] minVersionNums = minimumVersion.split(period+"|"+underscore);
     49        String[] runningVersionNums =runningJavaVersion.split(period+"|"+underscore);
     50       
     51        boolean acceptable = true;
     52        // only keep looping while we haven't gone past the end of either array
     53        int i=0;
     54        for(; i < minVersionNums.length && i < runningVersionNums.length; i++)
     55        {
     56            int min = Integer.parseInt(minVersionNums[i]);
     57            int run = Integer.parseInt(runningVersionNums[i]);
     58            if(run < min) {
     59                // fail: running version number is lower than corresponding
     60                // minimum version number
     61                acceptable = false;
     62                break;
     63            }
     64        }
     65       
     66        // Consider minVersion = 1.5.0_10 and runningVersion = 1.5.0
     67        // this means the runningversion is still insufficient.
     68        // HOWEVER, minVersion being longer does not always mean it is
     69        // a later version, consider: min=1.5.0_9.12 and run=1.5.0_10
     70        // This should be acceptable since 10 > 9 even though min is longer.
     71        // SOLUTION: If the last values for both were the same, the running
     72        // Version is not compatible if the minVersionNums array is longer
     73        int min = Integer.parseInt(minVersionNums[i-1]);
     74        int run = Integer.parseInt(runningVersionNums[i-1]);
     75       
     76        // if the last values were the same, check whether min is longer
     77        // in which case the running version is not acceptable
     78        if(min == run && minVersionNums.length > runningVersionNums.length)
     79        {
     80            acceptable = false;
     81        }
     82       
     83        if(acceptable) {
     84            System.out.println("Found compatible Java version " +runningJavaVersion);
     85            System.exit(2); // acceptable case
     86        } else {
     87            System.out.println("The current Java version " +
     88                runningJavaVersion + " is insufficient to run " + programName);
     89            System.exit(1);
     90        }
    2891    }
    29     catch (Exception exception) {
    30         System.err.println("Exception: " + exception);
    31     }
    32     }
    3392}
Note: See TracChangeset for help on using the changeset viewer.