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

 *    Release: @release@

 *

 *   '$Author: berkley $'

 *     '$Date: 2002-01-18 10:24:13 -0800 (Fri, 18 Jan 2002) $'

 * '$Revision: 899 $'

 *

 * 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.*;

import java.io.StringReader;

import java.util.Stack;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.EmptyStackException;

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, Runnable {

   private boolean	atFirstElement;

   private boolean	processingDTD;

   private String 	docname = null;

   private String 	doctype;

   private String 	systemid;

   private boolean 	stackCreated = false;

   private Stack 	  nodeStack;

   private Vector   nodeIndex;

   private Connection	  conn = null;

   private DocumentImpl currentDocument;

   private DBSAXNode    rootNode;

   private String   action = null;

   private String   docid = null;

   private String   user = null;

   private String[] groups = null;

   private String   pub = null;

   private Thread   xmlIndex;

   private boolean endDocument = false;

   private int serverCode = 1;

   private Hashtable namespaces = new Hashtable();

   private static final int MAXDATACHARS = 4000;

// DOCTITLE attr cleared from the db

//   private static final int MAXTITLELEN = 1000;

   /** Construct an instance of the handler class 

    *

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

    */

   public DBSAXHandler(Connection conn) {

     this.conn = conn;

     this.atFirstElement = true;

     this.processingDTD = false;

     // 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.

    *

    */

   public DBSAXHandler(Connection 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);

   }

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

   public void startDocument() throws SAXException {

     MetaCatUtil.debugMessage("start Document");

     // Create the document node representation as root

     rootNode = new DBSAXNode(conn, 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 {

     MetaCatUtil.debugMessage("end Document");

     // Starting new thread for writing XML Index.

     // It calls the run method of the thread.

     try {

       xmlIndex.start();

     } catch (NullPointerException e) {

       xmlIndex = null;

       throw new 

       SAXException("Problem with starting thread for writing XML Index. " +

                    e.getMessage());

     }

   }

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

   public void startPrefixMapping(String prefix, String uri) 

                                          throws SAXException

   {

    MetaCatUtil.debugMessage("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 {

     MetaCatUtil.debugMessage("Start ELEMENT " + qName);

     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;

     }

     // Document representation that points to the root document node

     if (atFirstElement) {

       atFirstElement = false;

       // If no DOCTYPE declaration: docname = root element name 

       if (docname == null) {

         docname = localName;

         doctype = docname;

         MetaCatUtil.debugMessage("DOCNAME-a: " + docname);

         MetaCatUtil.debugMessage("DOCTYPE-a: " + doctype);

       } else if (doctype == null) {

         doctype = docname;

         MetaCatUtil.debugMessage("DOCTYPE-b: " + doctype);

       }

       rootNode.writeNodename(docname);

       try {

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

         String catalogid = null;

         if ( systemid != null ) {

           Statement stmt = conn.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();

         }

         currentDocument = new DocumentImpl(conn, rootNode.getNodeID(), 

                               docname, doctype, docid, action, user, 

                               this.pub, catalogid, this.serverCode);

       } catch (Exception ane) {

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

                                 action, ane));

       }

     }      

     // Create the current node representation

     currentNode = new DBSAXNode(conn, qName, localName, parentNode,

                                 currentDocument.getRootNodeID(),docid,

                                 currentDocument.getDoctype());

     // 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++) {

       currentNode.setAttribute(atts.getQName(i), atts.getValue(i), docid);

     }      

     // 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);

  }

  /* The run method of xmlIndex thread. It writes XML Index for the document. */

  public void run () {

    DBSAXNode currNode = null;

    DBSAXNode prevNode = null;

    Connection dbconn = null;

    String doctype = currentDocument.getDoctype();

    int step = 0;

    int counter = 0;

    try {

      // Opening separate db connection for writing XML Index

      MetaCatUtil util = new MetaCatUtil();

      dbconn = util.openDBConnection();

      dbconn.setAutoCommit(false);

      //the following while loop construct checks to make sure that the docid

      //of the document that we are trying to index is already

      //in the xml_documents table.  if this is not the case, the foreign

      //key relationship between xml_documents and xml_index is temporarily

      //broken causing multiple problems.

      boolean inxmldoc = false;

      while(!inxmldoc)

      {

        String xmlDocumentsCheck = "select distinct docid from xml_documents";

        PreparedStatement xmlDocCheck = dbconn.prepareStatement(xmlDocumentsCheck);

        xmlDocCheck.execute();

        ResultSet doccheckRS = xmlDocCheck.getResultSet();

        boolean tableHasRows = doccheckRS.next();

        Vector docids = new Vector();

        while(tableHasRows) 

        {

          docids.add(doccheckRS.getString(1).trim());

          tableHasRows = doccheckRS.next();

        }

        for(int i=0; i<docids.size(); i++)

        {

          String d = ((String)docids.elementAt(i)).trim();

          if(docid.trim().equals(d))

          {

            inxmldoc = true;

          }

        }

        xmlDocCheck.close();

      }

      // Going through the elements of the document and writing its Index

      Enumeration nodes = nodeIndex.elements();

      while ( nodes.hasMoreElements() ) {

        currNode = (DBSAXNode)nodes.nextElement();

        currNode.updateNodeIndex(dbconn, docid, doctype);

      }

      dbconn.commit();

      //if this is a package file

      String packagedoctype = util.getOption("packagedoctype");

      Vector packagedoctypes = new Vector();

      packagedoctypes = MetaCatUtil.getOptionList(packagedoctype);

      if ( packagedoctypes.contains(doctype) )

      {

        // write the package info to xml_relation table

        RelationHandler rth = new RelationHandler(docid, dbconn);

        // from the relations get the access file id for that package

        String aclid = rth.getAccessFileID(docid);

        // if there are access file, write ACL for that package

        if ( aclid != null ) {

          runAccessControlList(dbconn, aclid);

        }

      }

      // if it is an access file

      else if ( MetaCatUtil.getOptionList(

                            util.getOption("accessdoctype")).contains(doctype) )

      {

        // write ACL for the package

        runAccessControlList(dbconn, docid);

      }

      dbconn.close();

    } catch (Exception e) {

      try {

        dbconn.rollback();

        dbconn.close();

      } catch (SQLException sqle) {}

      System.out.println("Error in DBSAXHandler.run " + e.getMessage());

      e.printStackTrace();

    }      

  }

  // It runs in xmlIndex thread. It writes ACL for a package.

  private void runAccessControlList (Connection conn, String aclid)

                                                throws Exception

  {

    // read the access file from xml_nodes

    // parse the access file and store the access info into xml_access

    AccessControlList aclobj = 

    new AccessControlList(conn, aclid, //new StringReader(xml),

                          user, groups, serverCode);

    conn.commit();

  }

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

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

     MetaCatUtil.debugMessage("CHARACTERS");

     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

       currentNode.writeChildNodeToDB("TEXT", null, data, docid);

     }

   }

   /** 

    * 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

     MetaCatUtil.debugMessage("IGNORABLEWHITESPACE");

     //System.out.println("Whitespace:" + len + "x" + new String(cbuf, start, len) + "x");

     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

       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 {

     MetaCatUtil.debugMessage("PI");

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

     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 {

     MetaCatUtil.debugMessage("End ELEMENT " + qName);

     // Get the node from the stack

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

   }

   //

   // 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;

     MetaCatUtil.debugMessage("Start DTD");

     MetaCatUtil.debugMessage("DOCNAME: " + docname);

     MetaCatUtil.debugMessage("DOCTYPE: " + doctype);

     MetaCatUtil.debugMessage("  SYSID: " + systemid);

   }

   /** 

    * SAX Handler that receives notification of end of DTD 

    */

   public void endDTD() throws SAXException {

     MetaCatUtil.debugMessage("end DTD");

   }

   /** 

    * SAX Handler that receives notification of comments in the DTD

    */

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

     MetaCatUtil.debugMessage("COMMENT");

     if ( !processingDTD ) {

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

       currentNode.writeChildNodeToDB("COMMENT", null, new String(ch), docid);

     }

   }

   /** 

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

    */

   public void startCDATA() throws SAXException {

     MetaCatUtil.debugMessage("start CDATA");

   }

   /** 

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

    */

   public void endCDATA() throws SAXException {

     MetaCatUtil.debugMessage("end CDATA");

   }

   /** 

    * SAX Handler that receives notification of the start of entities

    */

   public void startEntity(String name) throws SAXException {

     MetaCatUtil.debugMessage("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 {

     MetaCatUtil.debugMessage("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);

     MetaCatUtil.debugMessage("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);

     MetaCatUtil.debugMessage("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);

     MetaCatUtil.debugMessage("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);

     MetaCatUtil.debugMessage("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 {

     MetaCatUtil.debugMessage("FATALERROR");

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

   }

   /** 

    * SAX Handler that receives notification of recoverable parsing errors

    */

   public void error(SAXParseException exception) throws SAXException {

     MetaCatUtil.debugMessage("ERROR");

     throw (new SAXException("Processing error.", exception));

   }

   /** 

    * SAX Handler that receives notification of warnings

    */

   public void warning(SAXParseException exception) throws SAXException {

     MetaCatUtil.debugMessage("WARNING");

     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;

   }

}