Quadcap Embeddable Server

com/quadcap/services/DataSourcesParser.java

Go to the documentation of this file.

package com.quadcap.services;

/* Copyright 1999 - 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.Reader;
import java.io.IOException;

import java.util.Hashtable;

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.text.sax.Handler;

/**
 * Parser for Quadcap DataSource Deployment Descriptor.
 *
 * @author Stan Bailes
 */
/*{com.quadcap.services.DataSources.xml}
 *
 * <el><name>data-sources</name>
 *     <p>This document is used to define and initialize JDBC DataSources
 *        and bind them to a JNDI Context.</p>
 *
 *     <el><name>data-source</name>
 *         <p>Each DataSource definition has the following
 *            allowed elements:</p>
 *
 *         <el><name>jndi-name</name>
 *             <p>The JNDI name to bind this data source to.</p></el> 
 *
 *         <el><name>jdbc-url</name>
 *             <p>The JDBC URL of the connection.</p></el>
 *
 *         <el><name>connection-param</name>
 *             <p>A connection property, as a name/value pair.  The properties
 *                so specified are stored in a
 *                <code>java.util.Properties</code>
 *                object which is passed to the JDBC Driver's
 *                <code>getConnection()</code> method.</p>
 *
 *             <el><name>param-name</name>
 *                 <p>The name of a connection property</p></el> 
 *             <el><name>param-value</name>
 *                 <p>The value of a connection property</p></el>
 *         </el>
 *     </el>
 * </el>
 */
public class DataSourcesParser extends Handler {
    DataSources                 dss;
    DataSource                  ds;
    int                         state           = INIT;
    
    final static int            INIT            = 0;
    final static int            DATA_SOURCE     = 1;

    /**
     * Parser constructor
     */
    public DataSourcesParser() throws Exception {
        super();
    }
    
    /**
     * Parse the specified deployment descriptor in the context of the
     * specified DataSources object
     *
     * @param dd the reader containing the deployment descriptor
     * @param ds the DataSources object
     */
    public void parse(Reader dd, DataSources dss)
    {
        this.dss = dss;
        this.state = INIT;
        super.parse(dd, dss);
    }


    /**
     * SAX parser callback function called for the end of an element. 
     *
     * @param name the name of this element
     * @exception SAXException may be thrown 
     */
        try {
            switch (state) {
            case DATA_SOURCE:
                if (name.equals("data-source")) {
                    dss.addDataSource(ds);
                    env.clear();
                    state = INIT;
                } else if (name.equals("jndi-name")) {
                    ds.setName(consumeData());
                } else if (name.equals("driver-class")) {
                    ds.setDriverClass(consumeData());
                } else if (name.equals("jdbc-url")) {
                    ds.setUrl(consumeData());
                } else if (name.equals("connection-param")) {
                    ds.addConnectionProperty(consume("param-name"),
                                             consume("param-value"));
                } else {
                    env.put(name, consumeData());
                }
                break;
            case INIT:
                break;
            }
            throw e;
        } catch (Exception e) {
        }
    }

    /**
     * SAX parser callback for the start of an element.
     *
     * @param name the element name
     * @param attrs the element's attributes
     *
     * @exception SAXException may be thrown
     */
    {
        data.setLength(0);
        if (name.equals("data-source")) {
            ds = new DataSource();
            state = DATA_SOURCE;
        }
    }

}