Changeset 15690


Ignore:
Timestamp:
05/23/08 17:09:10 (13 years ago)
Author:
oranfry
Message:

split search4j into a library, and the utility itself. Yet to be tested for linux.

Location:
release-kits/shared/search4j
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • release-kits/shared/search4j

    • Property svn:ignore set to
      libsearch4j.obj
      search4j.obj

  • release-kits/shared/search4j/compile.bat

    r15093 r15690  
    1 cl /c -GX search4j.cpp
     1cl /c -GX /DWINDOWS=yes search4j.cpp
    22link advapi32.lib search4j.obj /out:search4j.exe
  • release-kits/shared/search4j/search4j.cpp

    r15133 r15690  
    55*/
    66
    7 #include <iostream>
    8 #include <fstream>
    9 #include <string>
    10 #include <sstream>
    11 
    12 using namespace std;
    13 
    14 #ifdef WINDOWS
    15 #include <windows.h>
    16 
    17 //minimal launch4j stuff
    18 #define NO_JAVA_FOUND 0
    19 #define FOUND_JRE 1
    20 #define FOUND_SDK 2
    21 int foundJava = NO_JAVA_FOUND;
    22 char foundJavaVer[128] = {0};
    23 
    24 //windows functions
    25 #define popen _popen
    26 #define strcmp _stricmp
    27 #endif /* WINDOWS */
    28 
    29 
    30 //global variables
    31 bool verbose = false;
    32 bool use_minimum = false;
    33 string hint = "";
    34 
    35 enum JvmProperty {
    36     JavaHome,
    37     Version,
    38     Executable
    39 };
     7#include "libsearch4j.h"
     8
     9void usage();
    4010
    4111enum Action {
     
    4515};
    4616
    47 void replace_all ( std::string & str, std::string const & pattern, std::string const & replacement ) {
    48 
    49     std::string::size_type start = str.find( pattern, 0 );
    50 
    51     while ( start != str.npos ) {
    52         str.replace( start, pattern.size(), replacement );
    53         start = str.find( pattern, start+replacement.size() );
    54     }
    55 
    56 }
    57 
    58 int process( string command, string &output ) {
    59    
    60     FILE *pPipe;
    61 
    62     /* Run command so that it writes its output to a pipe. Open this
    63     * pipe with read text attribute so that we can read it
    64     * like a text file. */
    65     char cmd[1024]; strcpy(cmd, command.c_str());
    66     //if ( verbose ) cout << "process(): running '" << command << "'" << endl;
    67     #ifdef WINDOWS
    68     if( (pPipe = popen( cmd, "rt" )) == NULL ) {
    69         if ( verbose ) cout << "could not start process" << endl;
    70         pclose( pPipe );
    71         return -1;
    72     }
    73     #endif
    74     #ifndef WINDOWS
    75     if( (pPipe = popen( cmd, "r" )) == NULL ) {
    76         if ( verbose ) cout << "could not start process" << endl;
    77         pclose( pPipe );
    78         return -1;
    79     }
    80     #endif
    81 
    82     //if ( verbose ) cout << "started process" << endl;
    83 
    84     /* Read pipe until end of file. */
    85     while( !feof( pPipe ) ) {
    86         char psBuffer[128];
    87         //if ( verbose ) cout << "get some data" << endl;
    88         if( fgets( psBuffer, 128, pPipe ) != NULL ) {
    89            
    90             //if ( verbose ) cout << "got: " << psBuffer << endl;
    91             output.append( psBuffer );
    92            
    93         } else {
    94             //if ( verbose ) cout << "none left" << endl;
    95         }
    96        
    97     }
    98 
    99     /* Close pipe and return return value of pPipe. */
    100     int code = pclose( pPipe );
    101     return code;
    102 }
    103 
    104 class Jvm {
    105 
    106     string javaHome;
    107    
    108     // version string. era.major.minor_update. eg: 1.4.2_02
    109     int era;
    110     int major;
    111     int minor;
    112     int update;
    113 
    114     bool isJdk;
    115     bool healthy;   
    116 
    117 
    118     public:
    119     Jvm() {
    120         healthy = false;
    121     }
    122 
    123     void setJavaHome( string jh ) {
    124         healthy = true;
    125         javaHome = jh;
    126         setVersionFromExeOuput();
    127     }
    128 
    129     string getJavaHome() {
    130         return javaHome;
    131     }
    132 
    133     string getExecutable() {
    134         string exec = "";
    135         exec.append( javaHome );
    136        
    137         #ifdef WINDOWS
    138         exec.append( "\\bin\\java.exe" );
    139         #endif
    140 
    141         #ifndef WINDOWS
    142         exec.append( "/bin/java" );
    143         #endif
    144        
    145         return exec;
    146     }
    147 
    148     string getVersion() {
    149         stringstream ss;
    150         ss << era << "." << major << "." << minor << "_" << update;
    151         return ss.str();
    152     }
    153    
    154     bool check() {
    155         return healthy;
    156     }
    157 
    158     bool setVersionFromString( string version ) {
    159         era = atoi( version.substr(0,1).c_str() );
    160         major = atoi( version.substr(2,1).c_str() );
    161         minor = atoi( version.substr(4,1).c_str() );
    162         update = atoi( version.substr(6,2).c_str() );
    163         return true;
    164     }
    165    
    166     int compare( Jvm otherJvm ) {
    167         //era
    168         if ( era > otherJvm.getEra() )
    169             return 1;
    170         else if ( era < otherJvm.getEra() )
    171             return -1;
    172        
    173         //major
    174         if ( major > otherJvm.getMajor() )
    175             return 1;
    176         else if ( major < otherJvm.getMajor() )
    177             return -1;
    178            
    179         //minor
    180         if ( minor > otherJvm.getMinor() )
    181             return 1;
    182         else if ( minor < otherJvm.getMinor() )
    183             return -1;
    184 
    185         //update
    186         if ( update > otherJvm.getUpdate() )
    187             return 1;
    188         else if ( update < otherJvm.getUpdate() )
    189             return -1;
    190 
    191         //all the same so far, must be exactly the same
    192         return 0;
    193 
    194     }
    195    
    196     int getEra() { return era; }
    197     int getMajor() { return major; }
    198     int getMinor() { return minor; }
    199     int getUpdate() { return update; }
    200    
    201     private:
    202    
    203     void setVersionFromExeOuput() {
    204         string command = "", output = "";
    205         command.append( "\"" );
    206         command.append( getExecutable() );
    207         command.append( "\"" );
    208         command.append(" -version 2>&1");
    209         //cout << "(command: " << command << ")";
    210         int result = process( command, output );
    211         //cout << "(output: " << output << ")";
    212         if ( result == 0 ) {
    213             if ( strcmp( output.substr( 0, 12 ).c_str() , "java version" ) == 0 || true ) {
    214                 era = atoi( output.substr(14,1).c_str() );
    215                 major = atoi( output.substr(16,1).c_str() );
    216                 minor = atoi( output.substr(18,1).c_str() );
    217                 update = atoi( output.substr(20,2).c_str() );
    218                 //if ( verbose) cout << "set version to: " << era << "." << major << "." << minor << "_" << update << endl;
    219             } else {
    220                 healthy=false;
    221             }
    222         } else {
    223             healthy = false;
    224         }
    225     }
    226    
    227    
     17enum JvmProperty {
     18    JavaHome,
     19    Version,
     20    Executable
    22821};
    22922
     
    24841}
    24942
    250 void usage() {
    251    
    252     cout
    253         << "-----------------" << endl
    254         << " search4j: usage" << endl
    255         << "-----------------" << endl
    256         << "Three usage methods: find, compare and launch" << endl
    257         << endl
    258         << "find:     find java and print out information about it" << endl
    259         << endl
    260         << "          search4j [-v|-e]" << endl
    261         << "          eg: search4j -e" << endl
    262         << endl
    263         << "          by default, print JAVA_HOME. E.g., C:\\Program Files\\jre1.5.0_15, or" << endl
    264         << "          if -v is specified, print the java version string. E.g. 1.5.0_15, or" << endl
    265         << "          if -e is specified, print the path the to the java executable. E.g. C:\\Program Files\\jre1.5.0_15\\bin\\java.exe" << endl
    266         << endl
    267         << "compare:  compare the found java with the given java version string" << endl
    268         << endl
    269         << "          search4j -c VERSION_STRING" << endl
    270         << "          eg: search4j -c VERSION_STRING" << endl
    271         << endl
    272         << "          print -1 if found java is older" << endl
    273         << "          print 0 if found java is same" << endl
    274         << "          print 1 if found java is newer" << endl
    275         << endl
    276         << "launch:   launch the given executable jar with the found java" << endl
    277         << endl
    278         << "          search4j -l EXECUTABLE_JAR [-m VERSION_STRING]" << endl
    279         << "          eg: search4j -l greenstone3.jar" << endl
    280         << endl
    281         << "          specify the location of the jar relative to the current directory" << endl
    282         << endl
    283         << "Global Options:" << endl
    284         << "          -m VERSION_STRING: (minimum) find a java of the given version or newer, or fail" << endl
    285         << "          -h LOCATION: (hint) as a last resort look for java in LOCATION (treated as a JAVA_HOME)" << endl
    286         << "          --verbose : have search4j print out information about what its doing" << endl
    287         << "          --help : display this usage screen" << endl
    288         << endl
    289         ;
    290 }
    291 
    292 //another global
    293 Jvm minimum;
    294 
    295 #ifdef WINDOWS
    296 void regSearch(HKEY hKey, const char* keyName, int searchType) {
    297     DWORD x = 0;
    298     unsigned long size = 1024;
    299     FILETIME time;
    300     char buffer[1024] = {0};
    301     while (RegEnumKeyEx(
    302                 hKey,           // handle to key to enumerate
    303                 x++,            // index of subkey to enumerate
    304                 buffer,         // address of buffer for subkey name
    305                 &size,          // address for size of subkey buffer
    306                 NULL,           // reserved
    307                 NULL,           // address of buffer for class string
    308                 NULL,           // address for size of class buffer
    309                 &time) == ERROR_SUCCESS) {
    310         strcpy(foundJavaVer, buffer);
    311         foundJava = searchType;
    312         size = 1024;
    313     }
    314 }
    315 #endif
    316 
    317 /*
    318 * function to find java
    319 * implements the logic drawn on the dl lab whiteboard in feb 08
    320 * return a Jvm object which represents the jvm on disk
    321 */
    322 bool find( Jvm &jvm ) {
    323    
    324     if ( verbose ) cout << "Searching for a JVM" << endl;
    325     char *javaHome = "";
    326     bool jvmFound = false;
    327    
    328     if ( !jvmFound ) {
    329         //try JAVA_HOME
    330         if ( verbose ) cout << " - trying JAVA_HOME: ";
    331         javaHome = getenv( "JAVA_HOME" );
    332         if ( javaHome != NULL ) {
    333             if ( verbose ) cout << "(" << javaHome << ") ";
    334             jvm.setJavaHome( javaHome );
    335             if ( jvm.check() ) {
    336                 if ( use_minimum ) {
    337                     if ( jvm.compare( minimum ) >= 0 ) {
    338                         jvmFound = true;
    339                     }
    340                 } else {
    341                     jvmFound = true;
    342                 }
    343             }
    344         }
    345         if ( verbose ) { if( jvmFound ) cout << "yes" << endl; else cout << "no" << endl; }
    346     }
    347    
    348     if ( !jvmFound ) {
    349         //try JRE_HOME
    350         if ( verbose ) cout << " - trying JRE_HOME: ";
    351         javaHome = getenv( "JRE_HOME" );
    352         if ( javaHome != NULL ) {
    353             if ( verbose ) cout << "(" << javaHome << ") ";
    354             jvm.setJavaHome( javaHome );
    355             if ( jvm.check() ) {
    356                 if ( use_minimum ) {
    357                     if ( jvm.compare( minimum ) >= 0 ) {
    358                         jvmFound = true;
    359                     }
    360                 } else {
    361                     jvmFound = true;
    362                 }
    363             }
    364         }
    365         if ( verbose ) { if( jvmFound ) cout << "yes" << endl; else cout << "no" << endl; }
    366     }
    367 
    368     #ifdef WINDOWS
    369     if ( !jvmFound ) {
    370         //try the registry - this code based on launch4j code
    371         if ( verbose ) cout << " - trying the registry: ";
    372         HKEY hKey;
    373         const char jre[] = "SOFTWARE\\JavaSoft\\Java Runtime Environment";
    374         const char sdk[] = "SOFTWARE\\JavaSoft\\Java Development Kit";
    375        
    376         if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(jre), 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hKey) == ERROR_SUCCESS ) {
    377             regSearch(hKey, jre, FOUND_JRE);
    378             RegCloseKey(hKey);
    379         }
    380        
    381         if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(sdk), 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hKey) == ERROR_SUCCESS ) {
    382             regSearch(hKey, sdk, FOUND_SDK);
    383             RegCloseKey(hKey);
    384         }
    385        
    386         if ( foundJava != NO_JAVA_FOUND ) {
    387             char path[1024] = {0};
    388             char keyBuffer[1024];
    389             unsigned long datatype;
    390             unsigned long bufferlength = 1024;
    391             if (foundJava == FOUND_JRE) {
    392                 strcpy(keyBuffer, jre);
    393             } else {
    394                 strcpy(keyBuffer, sdk);
    395             }
    396             strcat(keyBuffer, "\\");
    397             strcat(keyBuffer, foundJavaVer);
    398             if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(keyBuffer), 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) {
    399                 unsigned char buffer[1024] = {0};
    400                 if (RegQueryValueEx(hKey, "JavaHome", NULL, &datatype, buffer, &bufferlength) == ERROR_SUCCESS) {
    401                     int i = 0;
    402                     do {
    403                         path[i] = buffer[i];
    404                     } while (path[i++] != 0);
    405                     if (foundJava == FOUND_SDK) {
    406                         strcat(path, "\\jre");
    407                     }
    408                     jvm.setJavaHome( path );
    409                     if ( jvm.check() ) {
    410                         if ( use_minimum ) {
    411                             if ( jvm.compare( minimum ) >= 0 ) {
    412                                 jvmFound = true;
    413                             }
    414                         } else {
    415                             jvmFound = true;
    416                         }
    417                     }
    418                 }
    419                 RegCloseKey(hKey);
    420             }
    421         }
    422         if ( verbose ) { if( jvmFound ) cout << "yes" << endl; else cout << "no" << endl; }
    423     }
    424     #endif
    425 
    426     if ( !jvmFound ) {
    427         //try the hint
    428         if ( verbose ) cout << " - trying hint: ";
    429         if ( strcmp(hint.c_str(),"") != 0  ) {
    430             if ( verbose ) cout << "(" << hint << ") ";
    431             jvm.setJavaHome( hint );
    432             if ( jvm.check() ) {
    433                 if ( use_minimum ) {
    434                     if ( jvm.compare( minimum ) >= 0 ) {
    435                         jvmFound = true;
    436                     }
    437                 } else {
    438                     jvmFound = true;
    439                 }
    440             }
    441         }
    442         if ( verbose ) { if( jvmFound ) cout << "yes" << endl; else cout << "no" << endl; }
    443     }
    444 
    445 
    446     return jvmFound;
    447 }
    44843
    44944int main ( int argc, char** argv ) {
    450     //cout << "testing process()" << endl;
    451     //string out = "";
    452     //process( "dir", out );
    453     //cout << out << endl;
    454     //return 0;
    455 
    456 
     45
     46    bool verbose = false;
     47    string hint = "";
     48    bool use_minimum = false;
     49    bool useJavaw = false;
     50    Jvm minimum;
    45751    JvmProperty jvmProperty = JavaHome;
    45852    Action action = Find;
     
    507101                hint = argv[++i];
    508102            }
     103           
     104        #ifdef WINDOWS
     105        } else if ( strcmp(argv[i], "-w") == 0 ) {
     106            useJavaw = true;
     107        #endif
    509108
    510109        } else {
     
    521120    //find java
    522121    Jvm foundJvm;
    523     bool found = find( foundJvm );
     122    bool found = find( foundJvm, use_minimum, minimum, hint, verbose );
    524123
    525124    //check if it was found
     
    545144            cout << foundJvm.getVersion() << endl;
    546145        } else if ( jvmProperty == Executable ) {
    547             cout << foundJvm.getExecutable() << endl;
     146            if ( useJavaw ) {
     147                cout << foundJvm.getWinExecutable() << endl;
     148            } else {
     149                cout << foundJvm.getExecutable() << endl;
     150            }
    548151        } else {
    549152            return -1; //should never happen
     
    576179       
    577180        string cmd = "\"", output = "";
    578         cmd.append( foundJvm.getExecutable() );
     181        if ( useJavaw ) {
     182            cmd.append( foundJvm.getWinExecutable() );
     183        } else {
     184            cmd.append( foundJvm.getExecutable() );
     185        }
    579186        cmd.append( "\" -jar " );
    580187        cmd.append( arg1 );
    581188       
    582         process( cmd, output );
     189        process( cmd, true );
    583190       
    584191    }
     
    587194}
    588195
     196void usage() {
     197   
     198    cout
     199        << "-----------------" << endl
     200        << " search4j: usage" << endl
     201        << "-----------------" << endl
     202        << "Three usage methods: find, compare and launch" << endl
     203        << endl
     204        << "find:     find java and print out information about it" << endl
     205        << endl
     206        << "          search4j [-v|-e]" << endl
     207        << "          eg: search4j -e" << endl
     208        << endl
     209        << "          by default, print JAVA_HOME. E.g., C:\\Program Files\\jre1.5.0_15, or" << endl
     210        << "          if -v is specified, print the java version string. E.g. 1.5.0_15, or" << endl
     211        << "          if -e is specified, print the path the to the java executable. E.g. C:\\Program Files\\jre1.5.0_15\\bin\\java.exe" << endl
     212        << endl
     213        << "compare:  compare the found java with the given java version string" << endl
     214        << endl
     215        << "          search4j -c VERSION_STRING" << endl
     216        << "          eg: search4j -c VERSION_STRING" << endl
     217        << endl
     218        << "          print -1 if found java is older" << endl
     219        << "          print 0 if found java is same" << endl
     220        << "          print 1 if found java is newer" << endl
     221        << endl
     222        << "launch:   launch the given executable jar with the found java" << endl
     223        << endl
     224        << "          search4j -l EXECUTABLE_JAR [-m VERSION_STRING]" << endl
     225        << "          eg: search4j -l greenstone3.jar" << endl
     226        << endl
     227        << "          specify the location of the jar relative to the current directory" << endl
     228        << endl
     229        << "Global Options:" << endl
     230        << "          -m VERSION_STRING: (minimum) find a java of the given version or newer, or fail" << endl
     231        << "          -h LOCATION: (hint) as a last resort look for java in LOCATION (treated as a JAVA_HOME)" << endl
     232        << "          -w: (windows) find and/or use the javaw.exe executable instead of java.exe (in windows only)" << endl
     233        << "          --verbose : have search4j print out information about what its doing" << endl
     234        << "          --help : display this usage screen" << endl
     235        << endl
     236        ;
     237}
Note: See TracChangeset for help on using the changeset viewer.