Metacat

 *  '$RCSfile$'

 *    Release: @release@

 *

 *   '$Author$'

 *

 */

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

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

/**

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

public class DBSAXHandler extends DefaultHandler

                          implements LexicalHandler, DeclHandler, Runnable {

   private boolean	atFirstElement;

   private boolean	processingDTD;

   private String 	docname = null;

   private String 	doctype;

   private boolean 	stackCreated = false;

   private Stack 	  nodeStack;

   private DBConnection	  connection = null;

   private DocumentImpl currentDocument;

   private DBSAXNode    rootNode;

   private String   action = null;

   private String   revision = null;

   private String   user = null;

   private String[] groups = null;

   private String   pub = null;

   private Thread   xmlIndex;

   private int serverCode = 1;

   private Hashtable namespaces = new Hashtable();

   private static final int MAXDATACHARS = 4000;

// DOCTITLE attr cleared from the db

   /** Construct an instance of the handler class

    *

   public DBSAXHandler(DBConnection conn) {

     this.atFirstElement = true;

     this.processingDTD = false;

     // Create the stack for keeping track of node context

       nodeIndex = new Vector();

       stackCreated = true;

   }

    *

    * @param action - "INSERT" or "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

    */

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

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

   {

     this(conn);

     this.user = user;

     this.groups = groups;

     this.pub = pub;

     this.xmlIndex = new Thread(this);

   }

  /** Construct an instance of the handler class

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

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

   }

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

   public void startDocument() throws SAXException {

     MetaCatUtil.debugMessage("start Document", 50);

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

   }

   public void endDocument() throws SAXException {

     MetaCatUtil.debugMessage("end Document", 50);

     // Starting new thread for writing XML Index.

       throw new

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

   }

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

   public void startPrefixMapping(String prefix, String uri)

                                          throws SAXException

    MetaCatUtil.debugMessage("NAMESPACE", 50);

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

                            String qName, Attributes atts)

               throws SAXException {

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

     DBSAXNode parentNode = null;

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

       parentNode = null;

     }

     // Document representation that points to the root document node

     if (atFirstElement)

       atFirstElement = false;

       // If no DOCTYPE declaration: docname = root element

         docname = localName;

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

         doctype = docname;

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

       }

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

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

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

         // dbconnection from pool

         String catalogid = null;

         DBConnection dbConn = null;

         if ( systemid != null ) {

           try

            Statement stmt = dbConn.createStatement();

                          "SELECT catalog_id FROM xml_catalog " +

                          "WHERE entry_type = 'DTD' " +

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

            boolean hasRow = rs.next();

         }

         //create documentImpl object by the constructor which can specify

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

                               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(connection, qName, localName, parentNode,

                                 currentDocument.getRootNodeID(),docid,

     // Add all of the namespaces

     // Add all of the attributes

       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

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

  }

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

  public void run () {

    DBConnection dbConn = null;

    String doctype = currentDocument.getDoctype();

    int step = 0;

    try {

      // Opening separate db connection for writing XML Index

      dbConn=DBConnectionPool.getDBConnection("DBSAXHandler.run");

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

        PreparedStatement xmlDocCheck =

                                 dbConn.prepareStatement(xmlDocumentsCheck);

        xmlDocCheck.execute();

        while(tableHasRows)

        {

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

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

        currNode.updateNodeIndex(dbConn, docid, doctype);

      }

      dbConn.commit();

      //if this is a package file

      String packagedoctype = MetaCatUtil.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

          runAccessControlList(dbConn, aclid);

        }

      }

      // if it is an access file

      else if ( MetaCatUtil.getOptionList(

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

      {

        //runAccessControlList(dbConn, docid);

      }

      //dbconn.close();

    } catch (Exception e) {

        dbConn.rollback();

      } catch (SQLException sqle) {}

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

    }

    }//finally

  }

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

  private void runAccessControlList (DBConnection conn, String aclid)

                                                throws Exception

    AccessControlList aclobj =

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

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

     MetaCatUtil.debugMessage("CHARACTERS", 50);

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

     String data = null;

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

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

    */

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

     MetaCatUtil.debugMessage("IGNORABLEWHITESPACE", 50);

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

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

   }

   /**

    * node that PI may occur before or after the root element.

   public void processingInstruction(String target, String data)

          throws SAXException {

     MetaCatUtil.debugMessage("PI", 50);

     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,

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

     // Get the node from the stack

   }

   //

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

               throws SAXException {

     processingDTD = true;

     MetaCatUtil.debugMessage("Start DTD", 50);

     MetaCatUtil.debugMessage("Setting processingDTD to true", 50);

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

   }

   /**

    */

     processingDTD = false;

     MetaCatUtil.debugMessage("Setting processingDTD to false", 50);

     MetaCatUtil.debugMessage("end DTD", 50);

   }

   /**

    * SAX Handler that receives notification of comments in the DTD

     MetaCatUtil.debugMessage("COMMENT", 50);

     if ( !processingDTD ) {

   }

   /**

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

     MetaCatUtil.debugMessage("start CDATA", 50);

   }

   /**

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

     MetaCatUtil.debugMessage("end CDATA", 50);

   }

   /**

    * SAX Handler that receives notification of the start of entities

     MetaCatUtil.debugMessage("start ENTITY: " + name, 50);

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

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

   }

   /**

    * SAX Handler that receives notification of the end of entities

     MetaCatUtil.debugMessage("end ENTITY: " + name, 50);

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

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

   }

   /**

    * SAX Handler that receives notification of element declarations

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

     MetaCatUtil.debugMessage("ELEMENTDECL: " + name + " " + model, 50);

   }

   /**

    * SAX Handler that receives notification of attribute declarations

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

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

     MetaCatUtil.debugMessage("ATTRIBUTEDECL: " + eName + " "

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

                        + value, 50);

   }

   /**

    * SAX Handler that receives notification of internal entity declarations

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

     MetaCatUtil.debugMessage("INTERNENTITYDECL: " + name + " " + value, 50);

   }

   /**

    * SAX Handler that receives notification of external entity declarations

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

//                              + " " + systemId);

     MetaCatUtil.debugMessage("EXTERNENTITYDECL: " + name + " " + publicId

                              + " " + systemId, 50);

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

   }

   //

   /**

    * SAX Handler that receives notification of fatal parsing errors

     MetaCatUtil.debugMessage("FATALERROR", 50);

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

   /**

    * SAX Handler that receives notification of recoverable parsing errors

     MetaCatUtil.debugMessage("ERROR", 50);

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

   }

   /**

    * SAX Handler that receives notification of warnings

     MetaCatUtil.debugMessage("WARNING", 50);

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

   }

   //

   // Helper, getter and setter methods

   /**

   public boolean processingDTD() {

   }

}