Quadcap Embeddable Server

com/quadcap/server/ServerConfigParser.java

Go to the documentation of this file.

package com.quadcap.server;

/* Copyright 2000 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Properties;

import org.xml.sax.AttributeList;
import org.xml.sax.DocumentHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Parser;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.ParserFactory;

import com.quadcap.util.ConfigString;
import com.quadcap.util.Debug;

/*{com.quadcap.server.ServerConfigParser.xml}
 *
 * <el><name>server</name>
 *     <p>This document is used to configure and initialize QED services.</p>
 *
 *     <el><name>service</name>
 *         <p>Each service definition has the following allowed elements.</p>
 *
 *         <el><name>service-name</name>
 *             <p>The name of the service.</p>
 *         </el>
 *
 *         <el><name>service-class</name>
 *             <p>The name of the Java class which implements the service.</p>
 *         </el>
 *
 *         <el><name>service-config</name>
 *             <p>The name of a service configuration file.</p>
 *         </el>
 *
 *         <el><name>load-on-startup</name>
 *             <p>An integer value used to control the order in which
 *                services are loaded.  Lower values are started first.</p>
 *         </el>
 *
 *         <el><name>init-parameter</name>
 *             <p>String-valued configuration parameters may be supplied to
 *                a service.</p>
 *
 *             <el><name>param-name</name>
 *                 <p>The initialization/configuration parameter name.</p>
 *             </el>
 *
 *             <el><name>param-value</name>
 *                 <p>The initialization/configuration parameter value.</p>
 *             </el>
 *         </el>
 *     </el>
 * </el>
 */

/**
 * Parser the <code>server.xml</code> file to determine which services
 * should be loaded on startup.
 *
 * @author Stan Bailes
 */
public class ServerConfigParser implements DocumentHandler, ErrorHandler {
    ServiceContainer            container;
    Parser                      parser;
    Locator                     locator;
    StringBuffer                data            = new StringBuffer();
    ArrayList                   services        = new ArrayList();
    ServiceWrapper              service         = null;
    Properties                  props           = null;
    String                      paramName       = null;
    String                      paramValue      = null;

    static final int            INIT            = 0;
    static final int            SERVER          = 1;
    static final int            SERVICE         = 2;
    static final int            SERVICE_NAME    = 3;
    static final int            SERVICE_CLASS   = 4;
    static final int            SERVICE_CONFIG  = 5;
    static final int            LOAD_ON_STARTUP = 6;
    static final int            INIT_PARAMETER  = 7;
    static final int            PARAM_NAME      = 8;
    static final int            PARAM_VALUE     = 9;


    static HashMap              elemMap         = new HashMap();
    static {
        elemMap.put("server", new Integer(SERVER));
        elemMap.put("service", new Integer(SERVICE));
        elemMap.put("service-name", new Integer(SERVICE_NAME));
        elemMap.put("service-class", new Integer(SERVICE_CLASS));
        elemMap.put("service-config", new Integer(SERVICE_CONFIG));
        elemMap.put("load-on-startup", new Integer(LOAD_ON_STARTUP));
        elemMap.put("init-parameter", new Integer(INIT_PARAMETER));
        elemMap.put("param-name", new Integer(PARAM_NAME));
        elemMap.put("param-value", new Integer(PARAM_VALUE));
    }

    static final int mapElement(String name) {
        Integer i = (Integer)elemMap.get(name);
        if (i == null) return -1;
        return i.intValue();
    }

    /**
     * No-argument constructor.  The new object needs a database connection
     * before it can do anything useful.
     *
     * @exception Exception may be thrown if there's a problem constructing
     *  the XML parser.
     */
    public ServerConfigParser(ServiceContainer c) throws Exception {
        this.container = c;
        ConfigString ps = ConfigString.find("xml.sax.parser",
                                            "com.quadcap.text.sax.Parser");

        try {
            ClassLoader cl = ClassLoader.getSystemClassLoader();
            this.parser =
                (Parser)(Class.forName(ps.toString(), true, cl).newInstance());
        } catch (Throwable t) {
            Debug.print(t);
        }
        parser.setDocumentHandler(this);
        parser.setErrorHandler(this);
    }

    /**
     * Parse the specified file
     *
     * @exception may be thrown
     */
    public void parse(String fileName) throws Exception {
        FileReader f = new FileReader(fileName);
        try {
            BufferedReader r = new BufferedReader(f);
            parser.parse(is);
        } finally {
            f.close();
        }
    }

    /**
     * SAX parser callback to handle XML Parser errors.
     * This implementation just prints them
     * to System.err.
     *
     * @param exception the exception generated by the parser.
     */
        System.err.println("error");
        exception.printStackTrace(System.err);
    }

    /**
     * SAX parser callback to handle XML Parser fatal errors.
     * This implementation just prints them
     * to System.err.
     *
     * @param exception the exception generated by the parser.
     */
        System.err.println("fatal error");
        exception.printStackTrace(System.err);
    }

    /**
     * SAX parser callback to handle XML Parser fatal errors.  
     * This implementation just prints them
     * to System.err.
     *
     * @param exception the exception generated by the parser.
     */
        System.err.println("warning");
        exception.printStackTrace(System.err);
    }

    /**
     * SAX parser callback to handle character data found in the 
     * parsed document.
     *
     * @param ch the buffer containing the parsed characters.
     * @param star the buffer position of the first character
     * @param length the number of characters
     *
     * @exception SAXException may be thrown if this data represents
     *          a database value and there's a SQL exception thrown while
     *          trying to update the underlying resultset object with this
     *          data.
     */
    public void characters(char[] ch, int start, int length) 
    {
        data.append(ch, start, length);
    }

    /**
     * SAX parser callback function that is called when the end of the 
     * document is reached.  This implementation does nothing.
     */
    public void endDocument() {
    }

    /**
     * SAX parser callback function called for the end of an element. 
     * If this element
     * represents the <code>&lt;database&gt;</code> element, we finish up
     * by closing the active statement.  If this element represents a table
     * row element, we insert the current row.  Otherwise, we do nothing.
     *
     * @param name the name of this element
     * @exception SAXException may be thrown to wrap any underlying database
     *  exception.
     */
        switch (mapElement(name)) {
        case SERVER:
            addServices();
            break;
        case SERVICE:
            if (props != null) {
                service.setServiceProperties(props);
                props = null;
            }
            services.add(service);
            break;
        case SERVICE_NAME:
            service.setServiceName(consume());
            break;
        case SERVICE_CLASS:
            service.setServiceClass(consume());
            break;
        case LOAD_ON_STARTUP:
            service.setLoadOnStartup(Integer.parseInt(consume()));
            break;
        case SERVICE_CONFIG:
        {
            String cname = consume();
            getProps().setProperty("service.config", cname);
            try {
                getProps().putAll(parseProps(cname));
            } catch (IOException ex) {
            }
        }
            break;
        case PARAM_NAME:
            paramName = consume();
            break;
        case PARAM_VALUE:
            paramValue = consume();
            break;
        case INIT_PARAMETER:
            if (paramName != null && paramValue != null) {
                getProps().put(paramName, paramValue);
                paramName = null;
                paramValue = null;
            }
            break;
        default:
        }
    }

    final private Properties getProps() {
        if (props == null) props = new Properties();
        return props;
    }
    
    final public static Properties parseProps(String fileName)
        throws IOException
    {
        FileInputStream f = new FileInputStream(fileName);
        Properties p = new Properties();
        try {
            BufferedInputStream b = new BufferedInputStream(f);
            p.load(b);
        } finally {
            f.close();
        }
        return p;
    }

    /**
     * SAX parser callback for ignorable whitespace.  We just ignore it
     *
     * @param ch the buffer containing the parsed characters.
     * @param star the buffer position of the first character
     * @param length the number of characters
     */
    public void ignorableWhitespace(char[] ch, int start, int length) {
    }

    /**
     * SAX parser callback for processing instructions.  This implementation
     * does nothing.
     *
     * @param target the processing instruction target.
     * @param data the processing instruction data.
     */
    public void processingInstruction(String target, String data) {
    }

    /**
     * SAX parser callback used to receive a document locator.
     *
     * @param locator the parser's locator object.
     */
    public void setDocumentLocator(Locator locator) {
        this.locator = locator;
    }

    /**
     * SAX parser callback for document start.
     * This implementation does nothing.
     */
    public void startDocument() {
    }    

    /**
     * SAX parser callback for the start of an element.  If this element
     * represents a table row, and the table is different from the last
     * table seen, we establish an updatable <code>ResultSet</code> for the
     * new table which can be used to insert new rows into the table.
     * If this element represents a table row, we move to the insert row.
     * If this element represents a column, we remember the column name.
     *
     * @param name the element name
     * @param attrs the element's attributes
     *
     * @exception SAXException may be thrown to wrap an underlying database
     *          error, or if there is a problem with the XML document itself.
     */
    {
        data.setLength(0);
        switch (mapElement(name)) {
        case SERVICE:
            service = new ServiceWrapper();
            break;
        default:
            break;
        case -1:
        }
    }

    /**
     * Get and return all of the accumulated character data as a String.
     * Reset the character data buffer to be empty.
     */
    final String consume() {
        String s = data.toString().trim();
        data.setLength(0);
        return s;
    }

    /**
     * At the end of the file, add the services in the specified order
     */
        Exception ex = null;
        
        Collections.sort(services, new Comparator() {
            public int compare(Object a, Object b) {
                ServiceWrapper wa = (ServiceWrapper)a;
                ServiceWrapper wb = (ServiceWrapper)b;
                if (wa.getLoadOnStartup() < wb.getLoadOnStartup()) return -1;
                if (wa.getLoadOnStartup() > wb.getLoadOnStartup()) return 1;
                return 0;
            }
        });
        for (int i = 0; i < services.size(); i++) {
            ServiceWrapper w = (ServiceWrapper)services.get(i);
            try {
                container.addService(w.getServiceName(),
                                     w.getServiceClass(),
                                     w.getServiceProperties());
            } catch (Exception e) {
                ex = e;
                Debug.print(e);
            }
        }

        if (ex != null) throw new SAXException(ex);
    }
}