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: tao $'

 *     '$Date: 2003-02-14 17:23:36 -0800 (Fri, 14 Feb 2003) $'

 * '$Revision: 1410 $'

 *

 * 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 EmlSAXHandler extends DBSAXHandler implements 

                                                      AccessControlInterface

{

   private Vector allowRules = new Vector();

   private Vector denyRules = new Vector();

   private String documentId = null;

   private Vector subDocumentIdList = new Vector();

   private boolean processTopLeverAccess = false;

   private boolean processAdditionalAccess = false;

   private AccessSection accessObject= null;

   private AccessRule accessRule = null;

   private Hashtable topLevelAccessControlMap = new Hashtable();

   private Hashtable additionalAccessControlMap = new Hashtable();

   // Constant

   private static final String DESCRIBES = "describes";

   private static final String ADDITIONALMETADATA = "additionalMetadata";

   private static final String ORDER = "order";

   private static final String ID ="id";

    /** 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 EmlSAXHandler(DBConnection conn, String action, String docid,

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

   {

     super(conn, action, docid, user, groups, pub, serverCode);

   }

    /** 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 EmlSAXHandler(DBConnection conn, String action, String docid,

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

   {

     super(conn, action, docid, revision, user, groups, pub, serverCode);

   }

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

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

     MetaCatUtil.debugMessage("Start ELEMENT(localName) " + localName, 50);

     MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);

     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

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

         }

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

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

       } 

       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;

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

       }

       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

         String catalogid = null;

         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

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

                               docname, doctype, docid, revision, 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(connection, 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++) 

     {

       String attributeName = atts.getQName(i);

       String attributeValue = atts.getValue(i);

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

       }

     }

     // handle access stuff

     if (localName.equals(ACCESS))

     {

       // if it is in addtionalmetacat

       if (parentNode.getTagName() == ADDITIONALMETADATA)

       {

          processAdditionalAccess = true;

       }

       else

       {

         processTopLeverAccess = true;

       }

       // create access object 

        accessObject = new AccessSection();

         // set permission order

       String permOrder = currentNode.getAttribute(ORDER);

       accessObject.setPermissionOrder(permOrder);

       // set access id

       String accessId = currentNode.getAttribute(ID);

       accessObject.setAccessSectionId(accessId);

     }

     // Set up a access rule

     if (parentNode.getTagName() != null && 

       (parentNode.getTagName()).equals(ACCESS) && localName.equals(ALLOW))

     {

       accessRule = new AccessRule(); 

       //set permission type "allow"

       accessRule.setPermissionType(ALLOW);

     }

     // set up an access rule

     if (parentNode.getTagName() != null 

       && (parentNode.getTagName()).equals(ACCESS) && localName.equals(DENY))

     {

       accessRule = new AccessRule();

       //set permission type "allow"

       accessRule.setPermissionType(DENY);

     }

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

  }

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

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

  {

     super.characters(cbuf, start, len);

     // access stuff

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

     String currentTag = currentNode.getTagName();

     String data = null;

     // add principal

     if (currentTag.equals(PRINCIPAL) && accessRule != null) 

     {

        data = (new String(cbuf, start, len)).trim();

        accessRule.addPrincipal(data);

     } 

     else if (currentTag.equals(PERMISSION) && accessRule != null) 

     {

        data = (new String(cbuf, start, len)).trim();

        // we conbine different a permission into one value

        int permission = accessRule.getPermission();

        // add permision

        if ( data.toUpperCase().equals("READ") ) 

        {

          permission = permission | READ;

        } 

        else if ( data.toUpperCase().equals("WRITE") ) 

        {

          permission = permission | WRITE;

        } 

        else if ( data.toUpperCase().equals("CHANGEPERMISSION")) 

        {

          permission = permission | CHMOD;

        } 

        else if ( data.toUpperCase().equals("ALL") ) 

        {

          permission = permission | ALL;

        }

        accessRule.setPermission(permission);

     }

   }//character

  /** 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, 50);

     // Get the node from the stack

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

     // access stuff

     if ((currentNode.getTagName()).equals(ALLOW) ||

         (currentNode.getTagName()).equals(DENY))

     {

       // finish parser a ccess rule and  assign it to new one

       AccessRule newRule = accessRule;

       //add the new rule to access section object

       accessObject.addAccessRule(newRule);

       // reset access rule

       accessRule = null;

     }

     else if ((currentNode.getTagName()).equals(ACCESS))

     {

       // finish parse a access setction and assign it to new one

       AccessSection newAccessObject = accessObject;

       if (processTopLeverAccess)

       {

         // top level access control will handle whole document -docid

         topLevelAccessControlMap.put(docid, newAccessObject);

         // reset processtopleveraccess tag

         processTopLeverAccess =false;

       }

       else if (processAdditionalAccess)

       {

         // for additional control

       }

       //reset access section object

       accessObject = null;

     }

   }

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

   public void endDocument() throws SAXException 

   {

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

     // write access rule to db

     writeAccessRuleToDB();

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

     }

   }

  /* The method to write access rule into db. */

  private void writeAccessRuleToDB() throws SAXException

  {

    // for top document level

    AccessSection accessSection = (AccessSection)

                                          topLevelAccessControlMap.get(docid);

    // if accessSection is null stop it

    if( accessSection == null)

    {

      return;

    }

    String permOrder = accessSection.getPermissionOrder();

    String sql = "INSERT INTO xml_access (docid, principal_name, permission, "+

                 "perm_type, perm_order, accessfileid) VALUES " +

                 " (?, ?, ?, ?, ?, ?)";

    PreparedStatement pstmt = null;

    try 

    {

      pstmt = connection.prepareStatement(sql);

      // Increase DBConnection usage count

      connection.increaseUsageCount(1);

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.setString(6, docid);

      pstmt.setString(5, permOrder);

      Vector accessRules = accessSection.getAccessRules();

      // go through every rule

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

      {

        AccessRule rule = (AccessRule)accessRules.elementAt(i);

        String permType = rule.getPermissionType();

        int permission = rule.getPermission();

        pstmt.setInt(3, permission);

        pstmt.setString(4, permType);

        // go through every principle in rule

        Vector nameVector = rule.getPrincipal();

        for ( int j = 0; j < nameVector.size(); j++ ) 

       {

         String prName = (String)nameVector.elementAt(j);

         pstmt.setString(2, prName);

         pstmt.execute();

       }//for

     }//for

     pstmt.close();

    }//try 

    catch (SQLException e) 

    {

      throw new 

      SAXException("EMLSAXHandler.writeAccessRuletoDB(): " + e.getMessage());

    }//catch

    finally

    {

      try

      {

        pstmt.close();

      }

      catch(SQLException ee)

      {

        throw new 

        SAXException("EMLSAXHandler.writeAccessRuletoDB(): " + ee.getMessage());

      }

    }//finally

  }//writeAccessRuletoDB

}