Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles the SAX XML events as they

 *             are generated from XML documents

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Jivka Bojilova

 *

 *   '$Author: berkley $'

 *     '$Date: 2007-04-03 13:10:52 -0700 (Tue, 03 Apr 2007) $'

 * '$Revision: 3221 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.EmptyStackException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

import edu.ucsb.nceas.morpho.datapackage.Triple;

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

import org.apache.log4j.Logger;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.DefaultHandler;

/**

 * A database aware Class implementing callback bethods for the SAX parser to

 * call when processing the XML stream and generating events.

 */

public class DBSAXHandler extends DefaultHandler implements LexicalHandler,

        DeclHandler

{

    protected boolean atFirstElement;

    protected boolean processingDTD;

    protected String docname = null;

    protected String doctype;

    protected String catalogid = null;

    protected String systemid;

    private boolean stackCreated = false;

    protected Stack nodeStack;

    protected Vector nodeIndex;

    protected DBConnection connection = null;

    protected DocumentImpl currentDocument;

    protected String createDate = null;

    protected String updateDate = null;

    protected DBSAXNode rootNode;

    protected String action = null;

    protected String docid = null;

    protected String revision = null;

    protected String user = null;

    protected String[] groups = null;

    protected String pub = null;

    private boolean endDocument = false;

    protected int serverCode = 1;

    protected Hashtable namespaces = new Hashtable();

    protected boolean hitTextNode = false; // a flag to hit text node

    // a buffer to keep all text nodes for same element

    // it is for element was splited

    protected StringBuffer textBuffer = new StringBuffer();

    protected Stack textBufferStack = new Stack();

    protected static final int MAXDATACHARS = 4000;

    //protected static final int MAXDATACHARS = 50;

    // methods writeChildNodeToDB, setAttribute, setNamespace,

    // writeTextForDBSAXNode will increase endNodeId.

    protected long endNodeId = -1; // The end node id for a substree

    // DOCTITLE attr cleared from the db

    //   private static final int MAXTITLELEN = 1000;

    private boolean isRevisionDoc  = false;

    //HandlerTriple stuff

    TripleCollection tripleList = new TripleCollection();

    Triple currentTriple = new Triple();

    boolean startParseTriple = false;

    boolean hasTriple = false;

    public static final String ECOGRID = "ecogrid://";

    private Logger logMetacat = Logger.getLogger(DBSAXHandler.class);

    /**

     * Construct an instance of the handler class

     *

     * @param conn the JDBC connection to which information is written

     */

    private DBSAXHandler(DBConnection conn, String createDate, String updateDate)

    {

        this.connection = conn;

        this.atFirstElement = true;

        this.processingDTD = false;

        this.createDate = createDate;

        this.updateDate = updateDate;

        // Create the stack for keeping track of node context

        // if it doesn't already exist

        if (!stackCreated) {

            nodeStack = new Stack();

            nodeIndex = new Vector();

            stackCreated = true;

        }

    }

    /**

     * Construct an instance of the handler class

     *

     * @param conn the JDBC connection to which information is written

     * @param action - "INSERT" or "UPDATE"

     * @param docid to be inserted or updated into JDBC connection

     * @param user the user connected to MetaCat servlet and owns the document

     * @param groups the groups to which user belongs

     * @param pub flag for public "read" access on document

     * @param serverCode the serverid from xml_replication on which this

     *            document resides.

     *

     */

/* TODO excise this constructor because not used anywhere in project

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String user, String[] groups, String pub, int serverCode)

    {

        this(conn);

        this.action = action;

        this.docid = docid;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

        this.xmlIndex = new Thread(this);

    }

*/

    /**

     * Construct an instance of the handler class In this constructor, user can

     * specify the version need to upadate

     *

     * @param conn the JDBC connection to which information is written

     * @param action - "INSERT" or "UPDATE"

     * @param docid to be inserted or updated into JDBC connection

     * @param revision, the user specified the revision need to be update

     * @param user the user connected to MetaCat servlet and owns the document

     * @param groups the groups to which user belongs

     * @param pub flag for public "read" access on document

     * @param serverCode the serverid from xml_replication on which this

     *            document resides.

     *

     */

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String revision, String user, String[] groups, String pub,

            int serverCode, String createDate, String updateDate)

    {

        this(conn, createDate, updateDate);

        this.action = action;

        this.docid = docid;

        this.revision = revision;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

    }

    /** SAX Handler that receives notification of beginning of the document */

    public void startDocument() throws SAXException

    {

        logMetacat.info("start Document");

        // Create the document node representation as root

        rootNode = new DBSAXNode(connection, this.docid);

        // Add the node to the stack, so that any text data can be

        // added as it is encountered

        nodeStack.push(rootNode);

    }

    /** SAX Handler that receives notification of end of the document */

    public void endDocument() throws SAXException

    {

        logMetacat.info("end Document");

        // Starting new thread for writing XML Index.

        // It calls the run method of the thread.

        //if it is data package insert triple into relationtion table;

        if (doctype != null

                && MetaCatUtil.getOptionList(

                        MetaCatUtil.getOption("packagedoctype")).contains(

                        doctype) && hasTriple && !isRevisionDoc) {

            try {

                //initial handler and write into relationdb only for xml-documents

                if (!isRevisionDoc)

                {

                  RelationHandler handler = new RelationHandler(docid, doctype,

                        connection, tripleList);

                }

            } catch (Exception e) {

                logMetacat.error(

                        "Failed to write triples into relation table"

                                + e.getMessage());

                throw new SAXException(

                        "Failed to write triples into relation table "

                                + e.getMessage());

            }

        }

    }

    /** SAX Handler that is called at the start of Namespace */

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

        logMetacat.info("NAMESPACE");

        namespaces.put(prefix, uri);

    }

    /** SAX Handler that is called at the start of each XML element */

    public void startElement(String uri, String localName, String qName,

            Attributes atts) throws SAXException

    {

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namesapce

        logMetacat.info("Start ELEMENT(qName) " + qName);

        logMetacat.info("Start ELEMENT(localName) " + localName);

        logMetacat.info("Start ELEMENT(uri) " + uri);

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

        // Get a reference to the parent node for the id

        try {

            parentNode = (DBSAXNode) nodeStack.peek();

        } catch (EmptyStackException e) {

            parentNode = null;

        }

        // If hit a text node, we need write this text for current's parent

        // node

        // This will happend if the element is mixted

        if (hitTextNode && parentNode != null) {

            // write the textbuffer into db for parent node.

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, parentNode);

            // rest hitTextNode

            hitTextNode = false;

            // reset textbuffer

            textBuffer = null;

            textBuffer = new StringBuffer();

        }

        // Document representation that points to the root document node

        if (atFirstElement) {

            atFirstElement = false;

            // If no DOCTYPE declaration: docname = root element

            // doctype = root element name or name space

            if (docname == null) {

                docname = localName;

                // if uri isn't null doctype = uri(namespace)

                // othewise root element

                if (uri != null && !(uri.trim()).equals("")) {

                    doctype = uri;

                } else {

                    doctype = docname;

                }

                logMetacat.info("DOCNAME-a: " + docname);

                logMetacat.info("DOCTYPE-a: " + doctype);

            } else if (doctype == null) {

                // because docname is not null and it is declared in dtd

                // so could not be in schema, no namespace

                doctype = docname;

                logMetacat.info("DOCTYPE-b: " + doctype);

            }

            rootNode.writeNodename(docname);

            try {

                // for validated XML Documents store a reference to XML DB

                // Catalog

                // Because this is select statement and it needn't to roll back

                // if

                // insert document action fialed.

                // In order to decrease DBConnection usage count, we get a new

                // dbconnection from pool

                DBConnection dbConn = null;

                int serialNumber = -1;

                if (systemid != null) {

                    try {

                        // Get dbconnection

                        dbConn = DBConnectionPool

                                .getDBConnection("DBSAXHandler.startElement");

                        serialNumber = dbConn.getCheckOutSerialNumber();

                        Statement stmt = dbConn.createStatement();

                        ResultSet rs = stmt

                                .executeQuery("SELECT catalog_id FROM xml_catalog "

                                        + "WHERE entry_type = 'DTD' "

                                        + "AND public_id = '" + doctype + "'");

                        boolean hasRow = rs.next();

                        if (hasRow) {

                            catalogid = rs.getString(1);

                        }

                        stmt.close();

                    }//try

                    finally {

                        // Return dbconnection

                        DBConnectionPool.returnDBConnection(dbConn,

                                serialNumber);

                    }//finally

                }

                //create documentImpl object by the constructor which can

                // specify

                //the revision

                if (!isRevisionDoc)

                {

                  currentDocument = new DocumentImpl(connection, rootNode

                        .getNodeID(), docname, doctype, docid, revision,

                        action, user, this.pub, catalogid, this.serverCode, 

                        createDate, updateDate);

                }               

            } catch (Exception ane) {

                ane.printStackTrace();

                throw (new SAXException("Error in DBSaxHandler.startElement "

                        + action, ane));

            }

        }

        // Create the current node representation

        currentNode = new DBSAXNode(connection, qName, localName,

                parentNode, rootNode.getNodeID(), docid, doctype);

        // Add all of the namespaces

        String prefix;

        String nsuri;

        Enumeration prefixes = namespaces.keys();

        while (prefixes.hasMoreElements()) {

            prefix = (String) prefixes.nextElement();

            nsuri = (String) namespaces.get(prefix);

            currentNode.setNamespace(prefix, nsuri, docid);

        }

        namespaces = null;

        namespaces = new Hashtable();

        // Add all of the attributes

        for (int i = 0; i < atts.getLength(); i++) {

            String attributeName = atts.getQName(i);

            String attributeValue = atts.getValue(i);

            endNodeId = currentNode.setAttribute(attributeName, attributeValue,

                    docid);

            // To handle name space and schema location if the attribute name

            // is

            // xsi:schemaLocation. If the name space is in not in catalog table

            // it will be regeistered.

            if (attributeName != null

                    && attributeName

                            .indexOf(MetaCatServlet.SCHEMALOCATIONKEYWORD) != -1) {

                SchemaLocationResolver resolver = new SchemaLocationResolver(

                        attributeValue);

                resolver.resolveNameSpace();

            }

        }

        // Add the node to the stack, so that any text data can be

        // added as it is encountered

        nodeStack.push(currentNode);

        // Add the node to the vector used by thread for writing XML Index

        nodeIndex.addElement(currentNode);

        // start parsing triple

        if (doctype != null

                && MetaCatUtil.getOptionList(

                        MetaCatUtil.getOption("packagedoctype")).contains(

                        doctype) && localName.equals("triple")) {

            startParseTriple = true;

            hasTriple = true;

            currentTriple = new Triple();

        }

    }    

    /** SAX Handler that is called for each XML text node */

    public void characters(char[] cbuf, int start, int len) throws SAXException

    {

        logMetacat.info("CHARACTERS");

        // buffer all text nodes for same element. This is for text was splited

        // into different nodes

        textBuffer.append(new String(cbuf, start, len));

        // set hittextnode true

        hitTextNode = true;

        // if text buffer .size is greater than max, write it to db.

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS) {

            logMetacat.info("Write text into DB in charaters"

                    + " when text buffer size is greater than maxmum number");

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

            textBuffer = null;

            textBuffer = new StringBuffer();

        }

    }

    /**

     * SAX Handler that is called for each XML text node that is Ignorable

     * white space

     */

    public void ignorableWhitespace(char[] cbuf, int start, int len)

            throws SAXException

    {

        // When validation is turned "on", white spaces are reported here

        // When validation is turned "off" white spaces are not reported here,

        // but through characters() callback

        logMetacat.info("IGNORABLEWHITESPACE");

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        String data = null;

        int leftover = len;

        int offset = start;

        boolean moredata = true;

        // This loop deals with the case where there are more characters

        // than can fit in a single database text field (limit is

        // MAXDATACHARS). If the text to be inserted exceeds MAXDATACHARS,

        // write a series of nodes that are MAXDATACHARS long, and then the

        // final node contains the remainder

        while (moredata) {

            if (leftover > MAXDATACHARS) {

                data = new String(cbuf, offset, MAXDATACHARS);

                leftover -= MAXDATACHARS;

                offset += MAXDATACHARS;

            } else {

                data = new String(cbuf, offset, leftover);

                moredata = false;

            }

            // Write the content of the node to the database

            endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data,

                    docid);

        }

    }

    /**

     * SAX Handler called once for each processing instruction found: node that

     * PI may occur before or after the root element.

     */

    public void processingInstruction(String target, String data)

            throws SAXException

    {

        logMetacat.info("PI");

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

    }

    /** SAX Handler that is called at the end of each XML element */

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

        logMetacat.info("End ELEMENT " + qName);

        // write buffered text nodes into db (so no splited)

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        // If before the end element, the parser hit text nodes and store them

        // into the buffer, write the buffer to data base. The reason we put

        // write database here is for xerces some time split text node

        if (hitTextNode) {

            logMetacat.info("Write text into DB in End Element");

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

            //if it is triple parsing process

            if (startParseTriple) {

                String content = textBuffer.toString().trim();

                if (localName.equals("subject")) { //get the subject content

                    currentTriple.setSubject(content);

                } else if (localName.equals("relationship")) { //get the

                                                               // relationship

                                                               // content

                    currentTriple.setRelationship(content);

                } else if (localName.equals("object")) { //get the object

                                                         // content

                    currentTriple.setObject(content);

                }

            }

        }//if

        //set hitText false

        hitTextNode = false;

        // reset textbuff

        textBuffer = null;

        textBuffer = new StringBuffer();

        // Get the node from the stack

        currentNode = (DBSAXNode) nodeStack.pop();

        //finishing parsing single triple

        if (startParseTriple && localName.equals("triple")) {

            // add trip to triple collection

            tripleList.addTriple(currentTriple);

            //rest variable

            currentTriple = null;

            startParseTriple = false;

        }

    }

    //

    // the next section implements the LexicalHandler interface

    //

    /** SAX Handler that receives notification of DOCTYPE. Sets the DTD */

    public void startDTD(String name, String publicId, String systemId)

            throws SAXException

    {

        docname = name;

        doctype = publicId;

        systemid = systemId;

        processingDTD = true;

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        //create a DTD node and write docname,publicid and system id into db

        // we don't put the dtd node into node stack

        DBSAXNode dtdNode = new DBSAXNode(connection, name, publicId, systemId,

                currentNode, currentNode.getRootNodeID(), docid);

        logMetacat.info("Start DTD");

        logMetacat.info("Setting processingDTD to true");

        logMetacat.info("DOCNAME: " + docname);

        logMetacat.info("DOCTYPE: " + doctype);

        logMetacat.info("  SYSID: " + systemid);

    }

    /**

     * SAX Handler that receives notification of end of DTD

     */

    public void endDTD() throws SAXException

    {

        processingDTD = false;

        logMetacat.info("Setting processingDTD to false");

        logMetacat.info("end DTD");

    }

    /**

     * SAX Handler that receives notification of comments in the DTD

     */

    public void comment(char[] ch, int start, int length) throws SAXException

    {

        logMetacat.info("COMMENT");

        if (!processingDTD) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

                    new String(ch, start, length), docid);

        }

    }

    /**

     * SAX Handler that receives notification of the start of CDATA sections

     */

    public void startCDATA() throws SAXException

    {

        logMetacat.info("start CDATA");

    }

    /**

     * SAX Handler that receives notification of the end of CDATA sections

     */

    public void endCDATA() throws SAXException

    {

        logMetacat.info("end CDATA");

    }

    /**

     * SAX Handler that receives notification of the start of entities

     */

    public void startEntity(String name) throws SAXException

    {

        logMetacat.info("start ENTITY: " + name);

        //System.out.println("start ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = true;

        }

    }

    /**

     * SAX Handler that receives notification of the end of entities

     */

    public void endEntity(String name) throws SAXException

    {

        logMetacat.info("end ENTITY: " + name);

        //System.out.println("end ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = false;

        }

    }

    /**

     * SAX Handler that receives notification of element declarations

     */

    public void elementDecl(String name, String model)

            throws org.xml.sax.SAXException

    {

        //System.out.println("ELEMENTDECL: " + name + " " + model);

        logMetacat.info("ELEMENTDECL: " + name + " " + model);

    }

    /**

     * SAX Handler that receives notification of attribute declarations

     */

    public void attributeDecl(String eName, String aName, String type,

            String valueDefault, String value) throws org.xml.sax.SAXException

    {

        //System.out.println("ATTRIBUTEDECL: " + eName + " "

        //                        + aName + " " + type + " " + valueDefault + " "

        //                        + value);

        logMetacat.info("ATTRIBUTEDECL: " + eName + " " + aName + " "

                + type + " " + valueDefault + " " + value);

    }

    /**

     * SAX Handler that receives notification of internal entity declarations

     */

    public void internalEntityDecl(String name, String value)

            throws org.xml.sax.SAXException

    {

        //System.out.println("INTERNENTITYDECL: " + name + " " + value);

        logMetacat.info("INTERNENTITYDECL: " + name + " " + value);

    }

    /**

     * SAX Handler that receives notification of external entity declarations

     */

    public void externalEntityDecl(String name, String publicId, String systemId)

            throws org.xml.sax.SAXException

    {

        //System.out.println("EXTERNENTITYDECL: " + name + " " + publicId

        //                              + " " + systemId);

        logMetacat.info("EXTERNENTITYDECL: " + name + " " + publicId

                + " " + systemId);

        // it processes other external entity, not the DTD;

        // it doesn't signal for the DTD here

        processingDTD = false;

    }

    //

    // the next section implements the ErrorHandler interface

    //

    /**

     * SAX Handler that receives notification of fatal parsing errors

     */

    public void fatalError(SAXParseException exception) throws SAXException

    {

        logMetacat.fatal("FATALERROR: " + exception.getMessage());

        throw (new SAXException("Fatal processing error.", exception));

    }

    /**

     * SAX Handler that receives notification of recoverable parsing errors

     */

    public void error(SAXParseException exception) throws SAXException

    {

        logMetacat.error("ERROR: " + exception.getMessage());

        throw (new SAXException("Error in processing EML.", exception));

    }

    /**

     * SAX Handler that receives notification of warnings

     */

    public void warning(SAXParseException exception) throws SAXException

    {

        logMetacat.warn("WARNING: " + exception.getMessage());

        throw (new SAXException("Warning.", exception));

    }

    //

    // Helper, getter and setter methods

    //

    /**

     * get the document name

     */

    public String getDocname()

    {

        return docname;

    }

    /**

     * get the document processing state

     */

    public boolean processingDTD()

    {

        return processingDTD;

    }

    /**

     * get the the is revision doc

     * @return

     */

    public boolean getIsRevisionDoc()

    {

        return isRevisionDoc;

    }

    /**

     * Set the the handler is for revisionDoc

     * @param isRevisionDoc

     */

    public void setIsRevisionDoc(boolean isRevisionDoc)

    {

       this.isRevisionDoc = isRevisionDoc;   

    }

    /* Method to write a text buffer for DBSAXNode */

    protected long writeTextForDBSAXNode(long previousEndNodeId,

            StringBuffer strBuffer, DBSAXNode node) throws SAXException

    {

        long nodeId = previousEndNodeId;

        // Check parameter

        if (strBuffer == null || node == null) { return nodeId; }

        boolean moredata = true;

        String data = null;

        String normalizedData = strBuffer.toString();

        strBuffer = new StringBuffer(MetaCatUtil.normalize(normalizedData));

        int bufferSize = strBuffer.length();

        int start = 0;

        // if there are some cotent in buffer, write it

        if (bufferSize > 0) {

            logMetacat.info("Write text into DB");

            // This loop deals with the case where there are more characters

            // than can fit in a single database text field (limit is

            // MAXDATACHARS). If the text to be inserted exceeds MAXDATACHARS,

            // write a series of nodes that are MAXDATACHARS long, and then the

            // final node contains the remainder

            while (moredata) {

                bufferSize = strBuffer.length();

                if (bufferSize > MAXDATACHARS) {

                    data = strBuffer.substring(start, MAXDATACHARS);

                    // cut the stringbuffer part that already written into db

                    strBuffer = strBuffer.delete(start, MAXDATACHARS);

                } else {

                    data = strBuffer.substring(start, bufferSize);

                    moredata = false;

                }

                // Write the content of the node to the database

                nodeId = node.writeChildNodeToDB("TEXT", null, data, docid);

            }//while

        }//if

        return nodeId;

    }

    public long getRootNodeId()

    {

        return rootNode.getNodeID();

    }

    public String getDocumentType()

    {

        return doctype;

    }

    public String getDocumentName()

    {

        return docname;

    }

    public String getCatalogId()

    {

        return catalogid;

    }

}