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

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

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

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

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 org.xml.sax.SAXException;

import edu.ucsb.nceas.metacat.util.LDAPUtil;

import edu.ucsb.nceas.metacat.util.MetaCatUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

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

 * call when processing the XML stream and generating events

 * rules(he can update metadata but can't update access module) try to update

 * a document:

 * 1. Checking access part (both in top level and addtional level, node by node)

 *    If something was modified, reject the document. Note: for additional part

 *    The access subtree startnode starts at "<describ>" rather than <access>.

 *    This is because make sure ids wouldn't be mess up by user.

 * 2. Checking ids in additional access part, if they points a distribution

 *    module with online or inline. If some ids don't, reject the documents.

 * 3. For inline distribution:

 *    If user can't read the inline data, the empty string in inline element

 *    will be send to user if he read this eml document(user has read access

 *    at top level - metadata, but user couldn't read inline data).

 *    Here is some intrested senario: If user does have read and write

 *    permission in top level access rules(for metadata)

 *    but 1) user doesn't have read and write permission in inline data block,

 *    so if user update the document with some inline data rather than

 *    empty string in same inline data block(same distribution inline id),

 *    this means user updated the inline data. So the document should be

 *    rejected.

 *    2) user doesn't have read permssion, but has write premission in

 *    inline data block. If user send back inline data block with empty

 *    string, we will think user doesn't update inline data and we will

 *    copy old inline data back to the new one. If user send something

 *    else, we will overwrite the old inline data by new one.

 * 4. For online distribution:

 *    It is easy than inline distribution. When the user try to change a external

 *    document id, we will checking if the user have "all" permission to it.

 *    If don't have, reject the document. If have, delete the old rules and apply

 *    The new rules.

 *

 *

 * Here is some info about addtional access rules ( data object rules):

 *  The data access rules format looks like:

 *  <additionalMetadata>

 *    <describes>100</describes>

 *    <describes>300</describes>

 *    <access>rulesone</access>

 *  </additionalMetadata>

 *  <additionalMetadata>

 *    <describes>200</describes>

 *    <access>rulesthree</access>

 *  </additionalMetadata>

 *  Because eml additionalMetadata is (describes+, any) and any ocurrence is 1.

 *  So following xml will be rejected by xerces.

 *  <additionalMetadata>

 *    <describes>100</describes>

 *    <describes>300</describes>

 *    <other>....</other>

 *    <access>rulesone</access>

 *  </additionalMetadata>

public class Eml200SAXHandler extends DBSAXHandler implements

        AccessControlInterface

{

    private boolean processTopLeverAccess = false;

    // - data file

    private boolean processOtherAccess = false;

    private AccessSection accessObject = null;

    private AccessRule accessRule = null;

                                               //additionalmetadata/describes

    // id and  data  is url

    private Hashtable onlineURLDistributionIdList = new Hashtable();

    // distribution/oneline/url will store this vector if distribution doesn't

    // have a id.

    private Vector onelineURLDistributionListWithoutId = new Vector();

    // connection or connectiondefination. key is the distribution id

    // and  data  is distribution id

    private Hashtable onlineOtherDistributionIdList = new Hashtable();

    // key is the distribution id, data is the internal inline id

    private Hashtable inlineDistributionIdList = new Hashtable();

    // key is the distribution id, data is the id too.

    private Hashtable offlineDistributionIdList = new Hashtable();

    private Hashtable distributionAllIdList = new Hashtable();

    private String distributionId = null;

    private boolean proccessDistribution = false;

    // distribution has a id too. The key is itself id of this distribution,

    // the value is the referenced id.

    // So, we only stored the format like this:

    // <distribution id ="100"><reference>300</reference></distribution>

    // the reason is:

    // if not id in distribution, then the distribution couldn't be added

    // to additional access module. The distribution block which was referenced

    // id (300) will be stored in above distribution lists.

    private Hashtable distributionReferenceList = new Hashtable();

    private Hashtable possibleReferencedAccessHash = new Hashtable();

    // we need an another stack to store the access node which we pull out just

    // from xml. If a reference happend, we can use the stack the compare nodes

    private Stack storedAccessNodeStack = new Stack();

    // vector stored the data file id which will be write into relation table

    // Indicator of inline data

    private boolean handleInlineData = false;

    private Hashtable inlineDataNameSpace = null;

    private FileWriter inlineDataFileWriter = null;

    private String inlineDataFileName = null;

    private int inLineDataIndex = 0;

    private Vector inlineFileIDList = new Vector();

    private boolean unWritableInlineDataObject = false;

    //user has unreadable inline data when it updates a dcoument

    private boolean unReadableInlineDataObject = false;

    // the hashtable contains the info from xml_access table which

    // inline data the user can't read when user update a document.

    // The key in hashtable is subtree id and data is the inline data internal

    // file name.

    private Hashtable previousUnreadableInlineDataObjectHash = new Hashtable();

    // the hashtable contains the info from xml_access table which

    // inline data the user can't write when user update a document.

    // The key in hashtable is subtree id and data is the inline data internal

    // file name.

    private Hashtable previousUnwritableInlineDataObjectHash = new Hashtable();

    private Hashtable accessSubTreeAlreadyWriteDBList = new Hashtable();

    //This hashtable will stored the id which already has additional access

    // control. So the top level access control will ignore them.

    private Hashtable onlineURLIdHasAddtionalAccess   = new Hashtable();

    // additional access module will be in additionalMetadata part. Its format

    // look like

    //<additionalMetadata>

    //   <describes>100</describes>

    //   <describes>300</describes>

    //   <access>rulesone</access>

    //</additionalMetadata>

    // If user couldn't have all permission to update access rules, he/she could

    // not update access module, but also couldn't update "describes".

    // So the start node id for additional access section is the first describes

    // element

    private boolean firstDescribesInAdditionalMetadata = true;

    private long    firstDescribesNodeId               = -1;

    private int numberOfHitUnWritableInlineData = 0;

    private static final String EML = "eml";

    private static final String DESCRIBES = "describes";

    private static final String ADDITIONALMETADATA = "additionalMetadata";

    private static final String ORDER = "order";

    private static final String ID = "id";

    private static final String REFERENCES = "references";

    public static final String INLINE = "inline";

    private static final String ONLINE = "online";

    private static final String CONNECTION = "connection";

    private static final String CONNECTIONDEFINITION = "connectionDefinition";

        + "when they don't have write permission!";

        + "access module when they don't have \"ALL\" permission!";

    // place, but it was referenced by top or additional

    private static final String REFERENCEDLEVEL = "referenced";

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

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

                serverCode, createDate, updateDate);

        {

            // groups);

            //If the action is update and user doesn't have "ALL" permission

            // we need to check if user update access subtree

                unChangebleAdditionalAccessSubTreeVector =

                                         getAdditionalAccessSubTreeListFromDB();

                unChangebleReferencedAccessSubTreeHash =

                                         getReferencedAccessSubTreeListFromDB();

            //Here is for  data object checking.

            if (action != null && action.equals("UPDATE"))

            {

              //info about inline data object which user doesn't have read

              //permission the info come from xml_access table

              previousUnreadableInlineDataObjectHash = PermissionController.

                                                          groups, true);

              //info about data object which user doesn't have write permission

              // the info come from xml_accesss table

              previousUnwritableInlineDataObjectHash = PermissionController.

                                                          groups, true);

            }

        }

        catch (Exception e)

        {

                                     +e.getMessage());

        }

    }

     * Get the top level access subtree info from xml_accesssubtree table.

     * If no top access subtree found, null will be return.

     */

     private AccessSection getTopAccessSubTreeFromDB()

                                                       throws SAXException

     {

       AccessSection topAccess = null;

       PreparedStatement pstmt = null;

       ResultSet rs = null;

       String sql = "SELECT subtreeid, startnodeid, endnodeid "

                + "FROM xml_accesssubtree WHERE docid like ? "

                + "AND controllevel like ?";

       {

            pstmt = connection.prepareStatement(sql);

            // Increase DBConnection usage count

            connection.increaseUsageCount(1);

            // Bind the values to the query

            pstmt.setString(1, docid);

            pstmt.setString(2, TOPLEVEL);

            pstmt.execute();

            rs = pstmt.getResultSet();

            if (rs.next())

            {

                String sectionId = rs.getString(1);

                long startNodeId = rs.getLong(2);

                long endNodeId = rs.getLong(3);

                // create a new access section

                topAccess.setControlLevel(TOPLEVEL);

                topAccess.setDocId(docid);

                topAccess.setSubTreeId(sectionId);

                topAccess.setStartNodeId(startNodeId);

                topAccess.setEndNodeId(endNodeId);

            pstmt.close();

        }//try

        catch (SQLException e)

        {

            throw new SAXException(

                    "EMLSAXHandler.getTopAccessSubTreeFromDB(): "

                            + e.getMessage());

        }//catch

        finally

        {

            try

            {

                pstmt.close();

            }

            catch (SQLException ee)

            {

                throw new SAXException(

                        "EMLSAXHandler.getTopAccessSubTreeFromDB(): "

                                + ee.getMessage());

            }

        }//finally

        return topAccess;

    /*

     * Get the subtree node info from xml_accesssubtree table

     */

        Vector result = new Vector();

        PreparedStatement pstmt = null;

        ResultSet rs = null;

        {

            pstmt = connection.prepareStatement(sql);

            // Increase DBConnection usage count

            connection.increaseUsageCount(1);

            // Bind the values to the query

            pstmt.setString(1, docid);

            // Get result set

            rs = pstmt.getResultSet();

            {

                String sectionId = rs.getString(1);

                long startNodeId = rs.getLong(2);

                long endNodeId = rs.getLong(3);

                AccessSection accessObj = new AccessSection();

                accessObj.setSubTreeId(sectionId);

                accessObj.setStartNodeId(startNodeId);

                accessObj.setEndNodeId(endNodeId);

                // add this access obj into vector

                result.add(accessObj);

            pstmt.close();

        }//try

        {

        }//catch

        {

            try

            {

            catch (SQLException ee)

            {

                        "EMLSAXHandler.getAccessSubTreeListFromDB(): "

                                + ee.getMessage());

            }

        }//finally

        return result;

    }

    * Get the access subtree for referenced info from xml_accesssubtree table

    */

   private Hashtable getReferencedAccessSubTreeListFromDB() throws Exception

   {

       Hashtable result = new Hashtable();

       PreparedStatement pstmt = null;

       ResultSet rs = null;

       String sql = "SELECT subtreeid, startnodeid, endnodeid "

               + "FROM xml_accesssubtree WHERE docid like ? "

               + "AND controllevel like ? "

               + "ORDER BY startnodeid ASC";

       try

       {

           pstmt = connection.prepareStatement(sql);

           // Increase DBConnection usage count

           connection.increaseUsageCount(1);

           // Bind the values to the query

           pstmt.setString(1, docid);

           pstmt.setString(2, REFERENCEDLEVEL);

           pstmt.execute();

           // Get result set

           rs = pstmt.getResultSet();

           while (rs.next())

           {

               String sectionId = rs.getString(1);

               long startNodeId = rs.getLong(2);

               long endNodeId = rs.getLong(3);

               // create a new access section

               AccessSection accessObj = new AccessSection();

               accessObj.setControlLevel(DATAACCESSLEVEL);

               accessObj.setDocId(docid);

               accessObj.setSubTreeId(sectionId);

               accessObj.setStartNodeId(startNodeId);

               accessObj.setEndNodeId(endNodeId);

               // add this access obj into hastable

               if ( sectionId != null && !sectionId.trim().equals(""))

               {

                 result.put(sectionId, accessObj);

               }

           }

           pstmt.close();

       }//try

       catch (SQLException e)

       {

           throw new SAXException(

                   "EMLSAXHandler.getReferencedAccessSubTreeListFromDB(): "

                           + e.getMessage());

       }//catch

       finally

       {

           try

           {

               pstmt.close();

           }

           catch (SQLException ee)

           {

               throw new SAXException(

                       "EMLSAXHandler.getReferencedSubTreeListFromDB(): "

                               + ee.getMessage());

           }

       }//finally

       return result;

   }

    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(localName) " + localName);

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

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        if (!handleInlineData)

        {

            {

            catch (EmptyStackException e)

            {

            }

            //start handle inline data

            if (qName.equals(INLINE) && !inAddtionalMetaData)

            {

                inLineDataIndex++;

                //intitialize namespace hash for in line data

                inlineDataNameSpace = new Hashtable();

                //initialize file writer

                String docidWithoutRev = MetaCatUtil.getDocIdFromString(docid);

                try {

					logMetacat.error("Could not get property 'accNumSeparator'.  "

							+ "Setting separator to '.': "+ pnfe.getMessage());

				}

                inlineDataFileName = docidWithoutRev + seperator + revision

                        + seperator + inLineDataIndex;

                inlineDataFileWriter = createInlineDataFileWriter(inlineDataFileName);

                // put the inline file id into a vector. If upload failed,

                // metacat will

                // delete the inline data file

                inlineFileIDList.add(inlineDataFileName);

                if (distributionId != null)

                {

                  //check to see if this inline data is readable or writable to

                  // this user

                  if (!previousUnreadableInlineDataObjectHash.isEmpty() &&

                       previousUnreadableInlineDataObjectHash.containsKey(distributionId))

                  {

                      unReadableInlineDataObject = true;

                  }

                  if (!previousUnwritableInlineDataObjectHash.isEmpty() &&

                       previousUnwritableInlineDataObjectHash.containsKey(distributionId))

                  {

                     unWritableInlineDataObject = true;

                     numberOfHitUnWritableInlineData++;

                  }

                  // store the distributid and inlinedata filename into a hash

                  inlineDistributionIdList.put(distributionId, inlineDataFileName);

                }

            // node

            // This will happend if the element is mixted

            if (hitTextNode && parentNode != null)

            {

                if (needCheckingAccessModule

                        && (processAdditionalAccess || processOtherAccess || processTopLeverAccess)) {

                    // stored the pull out nodes into storedNode stack

                    NodeRecord nodeElement = new NodeRecord(-2, -2, -2, "TEXT",

                            null, null, MetaCatUtil.normalize(textBuffer

                                    .toString()));

                    storedAccessNodeStack.push(nodeElement);

                }

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

            {

                // 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("DOCTYPE-a: " + doctype);

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

                    // so could not be in schema, no namespace

                    doctype = docname;

                rootNode.writeNodename(docname);

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

                    int serialNumber = -1;

                    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 = 'Schema' "

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

                        boolean hasRow = rs.next();

                        if (hasRow) {

                            catalogid = rs.getString(1);

                        }

                        stmt.close();

                    finally {

                        // Return dbconnection

                        DBConnectionPool.returnDBConnection(dbConn,

                                serialNumber);

                    }//finally

                    //create documentImpl object by the constructor which can

                    // specify

                    //the revision

                    {

                       currentDocument = new DocumentImpl(connection, rootNode

                            createDate, updateDate);

                } catch (Exception ane) {

                    throw (new SAXException(

                            "Error in EMLSaxHandler.startElement " + action,

                            ane));

                }

            //==================================================================

            currentNode = new DBSAXNode(connection, qName, localName,

                    doctype);

            // If this element is a start point of subtree(section), it will be

            // stored

            // otherwise, it will be discated

            long startNodeId = currentNode.getNodeID();

            // Add all of the namespaces

            String prefix = null;

            String nsuri = null;

            Enumeration prefixes = namespaces.keys();

            {

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

                endNodeId = currentNode.setNamespace(prefix, nsuri, docid);

            }