CheckEnv.java

/*
 * JOnAS: Java(TM) Open Application Server
 * Copyright (C) 1999-2004 Bull S.A.
 * Contact: jonas-team@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 * Initial developer(s): ____________________________________.
 * Contributor(s): ______________________________________.
 *
 * --------------------------------------------------------------------------
 * $Id: CheckEnv.java,v 1.22 2004/03/24 15:11:23 benoitf Exp $
 * --------------------------------------------------------------------------
 */


package org.objectweb.jonas.tools;


import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;

import org.objectweb.jonas.common.JProp;

public class CheckEnv {

    public  static final int ENV_OK      = 0;
    public  static final int ENV_WARNING = 1;
    public  static final int ENV_ERROR   = 2;
    private static final int ENV_UNKNOWN = -1;
    private static int envStatus = ENV_UNKNOWN;

    private static final String INSTALL_ROOT = "install.root";
    private static final String JONAS_BASE   = "jonas.base";
    private static final String JAVA_NAMING_PROVIDER_URL = "java.naming.provider.url";
    private static final String DBM_SERVICE = "dbm";
    private static final String DATASOURCES = "jonas.service.dbm.datasources";
    private static final String DATASOURCE_CLASS_NAME = "datasource.classname";

    private static Hashtable classesToCheck = new Hashtable();
    static {
        classesToCheck.put("javax.ejb.EnterpriseBean", "ejb-2_1-api.jar");
        classesToCheck.put("javax.sql.DataSource", "jdbc2_0-stdext.jar");
        classesToCheck.put("javax.transaction.UserTransaction", "jta-spec1_0_1.jar");
        classesToCheck.put("org.apache.xerces.parsers.SAXParser", "xerces.jar");
        classesToCheck.put("javax.jms.Message", "jms.jar");
        classesToCheck.put("org.apache.regexp.REUtil", "jakarta-regexp-1.2.jar");
        classesToCheck.put("org.objectweb.joram.mom.dest.Topic", "joram-mom.jar");
        classesToCheck.put("org.objectweb.transaction.jta.TMService", "jotm.jar");
    }

    public static int getStatus() {

        Properties props = null;
        envStatus = ENV_OK;

        // Check classes
        Enumeration cList = classesToCheck.keys();
        while (cList.hasMoreElements()) {
            String cname = (String) cList.nextElement();
            if (!classIsAccessible(cname)) {
                System.err.println("JOnAS environment ERROR: Classes of '"
                                   + classesToCheck.get(cname) + "' not accessible");
                System.err.println("(The JOnAS package is bad)");
                envStatus = ENV_ERROR;
            }
        }

        // Check the 'install.root' system property
        // (JONAS_ROOT variable environment)
        try {
            String sRoot = System.getProperty(INSTALL_ROOT);
            if (sRoot == null) {
                System.err.println("JOnAS environment ERROR: '"
                                   + INSTALL_ROOT + "' system property not defined");
                envStatus = ENV_ERROR;
            } else {
                File fRoot = new File(sRoot);
                if (!fRoot.isDirectory()) {
                    System.err.println("JOnAS environment ERROR: Invalid 'JONAS_ROOT' value");
                    System.err.println("                         '" + sRoot + "' directory not exist");
                    envStatus = ENV_ERROR;
                } else {
                    System.out.println("");
                    System.out.println("- JONAS_ROOT value: ");
                    System.out.println("   " + sRoot);
                }
            }
        } catch (SecurityException e) {
            System.err.println("CheckEnv ERROR: Cannot get the '"
                               + INSTALL_ROOT + "' system property (" + e + ")");
            envStatus = ENV_ERROR;
        }

        // Check the 'jonas.base' system property
        // (JONAS_BASE variable environment)
        try {
            String sBase = System.getProperty(JONAS_BASE);
            if (sBase == null) {
                System.err.println("JOnAS environment ERROR: '"
                                   + JONAS_BASE + "' environment property not defined");
                envStatus = ENV_ERROR;
            } else {
                File fBase = new File(sBase);
                if (!fBase.isDirectory()) {
                    System.err.println("JOnAS environment ERROR: Invalid 'JOAS_BASE' value");
                    System.err.println("                         '" + sBase + "' directory not exist");
                    envStatus = ENV_ERROR;
                } else {
                    System.out.println("");
                    System.out.println("- JONAS_BASE value: ");
                    System.out.println("   " + sBase);
                }
            }
        } catch (SecurityException e) {
            System.err.println("CheckEnv ERROR: Cannot get the '"
                               + JONAS_BASE + "' system property (" + e + ")");
            envStatus = ENV_ERROR;
        }

        // Check jonas.properties and <datasource>.properties
        try {
            // Check jonas.properties
            boolean isServiceDbm = false;
            JProp jonasProps = JProp.getInstance();
 
            System.out.println("");
            System.out.println("- JOnAS Services:");
            System.out.println("   " + jonasProps.getValue("jonas.services", "none"));

            String[] services = jonasProps.getValueAsArray("jonas.services");
           
            if (services != null) {
                for (int i = 0; i < services.length; i++) {
                    if (DBM_SERVICE.equals(services[i])) {
                        isServiceDbm = true;
                    }
                    String serviceClass = jonasProps.getValue("jonas.service." + services[i] + ".class");
                    if (serviceClass == null) {
                        System.err.println("JOnAS environment ERROR: 'jonas.service."
                                           + services[i] + ".class' property not defined");
                        envStatus = ENV_ERROR;
                    } else {
                        if (!classIsAccessible(serviceClass)) {
                            System.err.println("JOnAS environment ERROR: '"
                                               + serviceClass + "' class not accessible ('"
                                               + services[i] + "' service class)");
                            envStatus = ENV_ERROR;
                        } 
                    }
                } 
            } else {
                envStatus = ENV_ERROR;
                System.err.println("JOnAS environment ERROR: jonas.services not defined in " 
                                   + "jonas.properties");
            }
            
            System.out.println("");
            System.out.println("- Contents of 'jonas.properties':");
            String jonasContent = jonasProps.toString();
            if (jonasContent.length() > 0) {  
                System.out.println(jonasProps.toString());
            } else {
                envStatus = ENV_ERROR;
                System.err.println("JOnAS environment ERROR : jonas.properties empty");
            }
            if (isServiceDbm) {
                // Check <datasource>.properties
                String dsList = jonasProps.getValue(DATASOURCES, "");
                StringTokenizer st = new StringTokenizer(dsList, ",");
                String dsName = null;
                while (st.hasMoreTokens()) {
                    try {
                        dsName = st.nextToken().trim();
                        JProp dsProps = JProp.getInstance(dsName);
                        System.out.println("");
                        System.out.println("- Contents of '" + dsName + ".properties':");
                        System.out.println(dsProps.toString());
                        String driverName = dsProps.getValue(DATASOURCE_CLASS_NAME, "");
                        if (!classIsAccessible(driverName)) {
                            System.err.println("JOnAS environment ERROR: '"
                                               + driverName + "' class not accessible ('"
                                               + dsName + "' datasource's driver)");
                            envStatus = ENV_ERROR;
                        }
                    } catch (Exception e) {
                        System.err.println("JOnAS environment ERROR: '"
                                           + dsName + ".properties' "
                                           + "not available in JONAS_BASE/conf");
                        envStatus = ENV_ERROR;
                    }
                }
            }
        } catch (Exception e) {
            System.err.println("JOnAS environment ERROR: 'jonas.properties' not accessible (" + e + ")");
            envStatus = ENV_ERROR;
        }

        // Check trace.properties
        if (getProperties("trace.properties") == null) {
            System.err.println("JOnAS environment ERROR: 'trace.properties' not accessible");
            envStatus = ENV_ERROR;
        }

        // Check carol.properties
        if (getProperties("carol.properties") == null) {
            System.err.println("JOnAS environment ERROR: 'carol.properties' not accessible");
            envStatus = ENV_ERROR;
        }

        // Check jonas-realm.xml file
        System.out.println("\n- Check 'jonas-realm.xml':");
        try {
            JProp jProp = JProp.getInstance();
            String jonasBase = JProp.getJonasBase();
            File f = new File(jonasBase + File.separator + "conf" + File.separator + "jonas-realm.xml");
            if (!f.exists()) {
                System.err.println("The file jonas-realm.xml was not found in your JONAS_BASE/conf directory");
                envStatus = ENV_ERROR;
            } else {
                System.out.println("  File is present.");
            }
        } catch (Exception fe) {
            System.err.println("Error while checking the jonas-realm.xml file : " + fe.getMessage());
            envStatus = ENV_ERROR;
        }

        return envStatus;
    }

    public static void main(String args[]) {
        boolean isHelp    = false;
        boolean isVerbose = true;
        // Get args
        for (int argn = 0; argn < args.length; argn++) {
            String arg = args[argn];
            if (arg.equals("-help") || arg.equals("-?")) {
                isHelp = true;
                continue;
            }
        }
        // Usage ?
        if (isHelp) {
            usage();
            System.exit(0);
        }

        // Status
        int status = getStatus();
        System.out.println("");
        if (status == ENV_OK) {
            System.err.println("The JOnAS environment seems correct.");
            System.exit(0);
        } else if (status == ENV_WARNING) {
            System.err.println("WARNING: The JOnAS environment may be incomplete.");
            System.exit(1);
        } else if (status == ENV_ERROR) {
            System.err.println("ERROR: The JOnAS environment is NOT correct.");
            System.exit(2);
        }
    }

    static boolean classIsAccessible(String name) {
        try {
            Class.forName(name);
            return true;
        } catch (Exception e) {
            return false;
        } catch (Error e) {
            System.err.println(e);
            return false;
        }
    }

    // Return null if properties are not accessible
    static Properties getProperties(String name) {
        boolean isAccessible = true;
        Properties props = null;
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(name);
        if (is != null) {
            props = new Properties();
            try {
                props.load(is);
                
                System.out.println("");
                System.out.println("- Contents of '" + name + "':");
                if (props.isEmpty()) {
                    System.out.println("JOnAS environment ERROR :'" + name + "' is empty");
                    envStatus = ENV_ERROR;
                } else {
                    System.out.println("  (" + Thread.currentThread().getContextClassLoader().getResource(name).toString() + ")");
                    Enumeration pList = props.propertyNames();
                    while (pList.hasMoreElements()) {
                        String pname = (String) pList.nextElement();
                        System.out.println("   " + pname + " = " + props.getProperty(pname));
                    }
                }
            } catch (IOException e) {
                props = null;
            }
        } else {
            props = null;
        }
        return props;
    }

    private static void usage() {
        System.out.println("");
        System.out.println("Usage: CheckEnv [ -help | -? ]");
        System.out.println("    to print this help message");
        System.out.println("");
        System.out.println("or     CheckEnv");
        System.out.println("    to check if the JOnAS environment is correct or not,");
        System.out.println("    and to display the content of the configuration files.");
        System.out.println("");
    }

}

---