Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A class to asyncronously do delta-T replication checking

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2005-11-01 17:01:21 -0800 (Tue, 01 Nov 2005) $'

 * '$Revision: 2713 $'

 *

 * 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 edu.ucsb.nceas.dbadapter.AbstractDatabase;

import java.sql.*;

import java.util.*;

import java.util.Date;

import java.lang.Thread;

import java.io.*;

import java.net.*;

import java.text.*;

import org.apache.log4j.Logger;

import org.xml.sax.AttributeList;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.XMLReader;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.XMLReaderFactory;

import org.xml.sax.helpers.DefaultHandler;

/**

 * This class handles deltaT replication checking.  Whenever this TimerTask

 * is fired it checks each server in xml_replication for updates and updates

 * the local db as needed.

 */

public class ReplicationHandler extends TimerTask

{

  int serverCheckCode = 1;

  MetaCatUtil util = new MetaCatUtil();

  ReplicationServerList serverList = null;

  //PrintWriter out;

  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;

  private static Logger logMetacat = Logger.getLogger(ReplicationHandler.class);

  public ReplicationHandler()

  {

    //this.out = o;

    serverList = new ReplicationServerList();

  }

  public ReplicationHandler(int serverCheckCode)

  {

    //this.out = o;

    this.serverCheckCode = serverCheckCode;

    serverList = new ReplicationServerList();

  }

  /**

   * Method that implements TimerTask.run().  It runs whenever the timer is

   * fired.

   */

  public void run()

  {

    //find out the last_checked time of each server in the server list and

    //send a query to each server to see if there are any documents in

    //xml_documents with an update_date > last_checked

    try

    {

      //if serverList is null, metacat don't need to replication

      if (serverList==null||serverList.isEmpty())

      {

        return;

      }

      updateCatalog();

      update();

      //conn.close();

    }//try

    catch (Exception e)

    {

      logMetacat.error("Error in replicationHandler.run():"

                                                    +e.getMessage());

      e.printStackTrace();

    }//catch

  }

  /**

   * Method that uses revision taging for replication instead of update_date.

   */

  private void update()

  {

    /*

     Pseudo-algorithm

     - request a doc list from each server in xml_replication

     - check the rev number of each of those documents agains the

       documents in the local database

     - pull any documents that have a lesser rev number on the local server

       from the remote server

     - delete any documents that still exist in the local xml_documents but

       are in the deletedDocuments tag of the remote host response.

     - update last_checked to keep track of the last time it was checked.

       (this info is theoretically not needed using this system but probably

       should be kept anyway)

    */

    ReplicationServer replServer = null; // Variable to store the

                                        // ReplicationServer got from

                                        // Server list

    String server = null; // Variable to store server name

    String update;

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

    XMLReader parser;

    URL u;

    try

    {

      parser = initParser(message);

    }

    catch (Exception e)

    {

      MetacatReplication.replErrorLog("Failed to replicate becaue couldn't "+

                                 " initParser for message and" +e.getMessage());

      logMetacat.error("Failed to replicate becaue couldn't " +

                            " initParser for message and " +e.getMessage());

       // stop replication

       return;

    }

    //Check for every server in server list to get updated list and put

    // them in to response

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

    {

        // Get ReplicationServer object from server list

        replServer = serverList.serverAt(i);

        // Get server name from ReplicationServer object

        server = replServer.getServerName().trim();

        String result = null;

        MetacatReplication.replLog("full update started to: " + server);

        // Send command to that server to get updated docid information

        try

        {

          u = new URL("https://" + server + "?server="

          +util.getLocalReplicationServerName()+"&action=update");

          logMetacat.info("Sending infomation " +u.toString());

          result = MetacatReplication.getURLContent(u);

        }

        catch (Exception e)

        {

          MetacatReplication.replErrorLog("Failed to get updated doc list "+

                          "for server " + server + " because "+e.getMessage());

          logMetacat.error( "Failed to get updated doc list "+

                       "for server " + server + " because "+e.getMessage());

          continue;

        }

        logMetacat.info("docid: "+server+" "+result);

        //check if result have error or not, if has skip it.

        if (result.indexOf("<error>")!=-1 && result.indexOf("</error>")!=-1)

        {

          MetacatReplication.replErrorLog("Failed to get updated doc list "+

                          "for server " + server + " because "+result);

          logMetacat.info( "Failed to get updated doc list "+

                       "for server " + server + " because "+result);

          continue;

        }

        //Add result to vector

        responses.add(result);

    }

    //make sure that there is updated file list

    //If response is null, metacat don't need do anything

    if (responses==null || responses.isEmpty())

    {

        MetacatReplication.replErrorLog("No updated doc list for "+

                           "every server and failed to replicate");

        logMetacat.info( "No updated doc list for "+

                           "every server and failed to replicate");

        return;

    }

    logMetacat.info("Responses from remote metacat about updated "+

                   "document information: "+ responses.toString());

    // go through response vector(it contains updated vector and delete vector

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

    {

        try

        {

          parser.parse(new InputSource(

                     new StringReader(

                     (String)(responses.elementAt(i)))));

        }

        catch(Exception e)

        {

          MetacatReplication.replErrorLog("Couldn't parse one responses "+

                           "because "+ e.getMessage());

          logMetacat.error("Couldn't parse one responses "+

                                   "because "+ e.getMessage());

          continue;

        }

        //v is the list of updated documents

        Vector updateList = new Vector(message.getUpdatesVect());

        //System.out.println("v: " + v.toString());

        //d is the list of deleted documents

        Vector deleteList = new Vector(message.getDeletesVect());

        //System.out.println("d: " + d.toString());

        logMetacat.info("Update vector size: "+ updateList.size());

        logMetacat.info("Delete vector size: "+ deleteList.size());

        // go though every element in updated document vector

        handleDocList(updateList, DocumentImpl.DOCUMENTTABLE);

        //handle deleted docs

        for(int k=0; k<deleteList.size(); k++)

        { //delete the deleted documents;

          Vector w = new Vector((Vector)deleteList.elementAt(k));

          String docId = (String)w.elementAt(0);

          try

          {

            handleDeleteSingleDocument(docId, server);

          }

          catch (Exception ee)

          {

            continue;

          }

        }//for delete docs

        // handle replicate doc in xml_revision

        Vector revisionList = new Vector(message.getRevisionsVect());

        handleDocList(revisionList, DocumentImpl.REVISIONTABLE);

    }//for response

    //updated last_checked

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

    {

       // Get ReplicationServer object from server list

       replServer = serverList.serverAt(i);

       try

       {

         updateLastCheckTimeForSingleServer(replServer);

       }

       catch(Exception e)

       {

         continue;

       }

    }//for

  }//update

  /* Handle replicate single xml document*/

  private void handleSingleXMLDocument(String remoteserver, String actions,

                                       String accNumber, String tableName)

               throws Exception

  {

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.handleSingleXMLDocument");

      serialNumber=dbConn.getCheckOutSerialNumber();

      //if the document needs to be updated or inserted, this is executed

      String readDocURLString = "https://" + remoteserver + "?server="+

              util.getLocalReplicationServerName()+"&action=read&docid="+accNumber;

      readDocURLString = MetaCatUtil.replaceWhiteSpaceForURL(readDocURLString);

      URL u = new URL(readDocURLString);

      // Get docid content

      String newxmldoc = MetacatReplication.getURLContent(u);

      // If couldn't get skip it

      if ( newxmldoc.indexOf("<error>")!= -1 && newxmldoc.indexOf("</error>")!=-1)

      {

         throw new Exception(newxmldoc);

      }

      //logMetacat.info("xml documnet:");

      //logMetacat.info(newxmldoc);

      // Try get the docid info from remote server

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = initParser(dih);

      String docInfoURLStr = "https://" + remoteserver +

                       "?server="+util.getLocalReplicationServerName()+

                       "&action=getdocumentinfo&docid="+accNumber;

      docInfoURLStr = MetaCatUtil.replaceWhiteSpaceForURL(docInfoURLStr);

      URL docinfoUrl = new URL(docInfoURLStr);

      logMetacat.info("Sending message: " +

                                                  docinfoUrl.toString());

      String docInfoStr = MetacatReplication.getURLContent(docinfoUrl);

      docinfoParser.parse(new InputSource(new StringReader(docInfoStr)));

      Hashtable docinfoHash = dih.getDocInfo();

      // Get home server of the docid

      String docHomeServer = (String)docinfoHash.get("home_server");

      logMetacat.info("doc home server in repl: "+docHomeServer);

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

      //docid should include rev number too

      /*String accnum=docId+util.getOption("accNumSeparator")+

                                              (String)docinfoHash.get("rev");*/

      logMetacat.info("docid in repl: "+accNumber);

      String docType = (String)docinfoHash.get("doctype");

      logMetacat.info("doctype in repl: "+docType);

      String parserBase = null;

      // this for eml2 and we need user eml2 parser

      if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_0_0NAMESPACE))

      {

         parserBase = DocumentImpl.EML200;

      }

      else if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_0_1NAMESPACE))

      {

        parserBase = DocumentImpl.EML200;

      }

      else if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_1_0NAMESPACE))

      {

        parserBase = DocumentImpl.EML210;

      }

      // Write the document into local host

      DocumentImplWrapper wrapper = new DocumentImplWrapper(parserBase, false);

      String newDocid = wrapper.writeReplication(dbConn,

                              new StringReader(newxmldoc),

                              (String)docinfoHash.get("public_access"),

                              null,  /* the dtd text */

                              actions,

                              accNumber,

                              (String)docinfoHash.get("user_owner"),

                              null, /* null for groups[] */

                              docHomeServer,

                              remoteserver, tableName, true,// true is for time replication 

                              createdDate,

                              updatedDate);

      logMetacat.info("Successfully replicated doc " + accNumber);

      MetacatReplication.replLog("wrote doc " + accNumber + " from " +

                                         remoteserver);

    }//try

    catch(Exception e)

    {

      MetacatReplication.replErrorLog("Failed to write doc " + accNumber +

                                      " into db because " +e.getMessage());

      logMetacat.error("Failed to write doc " + accNumber +

                                      " into db because " +e.getMessage());

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* Handle replicate single xml document*/

  private void handleSingleDataFile(String remoteserver, String actions,

                                    String accNumber, String tableName)

               throws Exception

  {

    logMetacat.info("Try to replicate data file: "+accNumber);

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.handleSinlgeDataFile");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // Try get docid info from remote server

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = initParser(dih);

      String docInfoURLString = "https://" + remoteserver +

                  "?server="+util.getLocalReplicationServerName()+

                  "&action=getdocumentinfo&docid="+accNumber;

      docInfoURLString = MetaCatUtil.replaceWhiteSpaceForURL(docInfoURLString);

      URL docinfoUrl = new URL(docInfoURLString);

      String docInfoStr = MetacatReplication.getURLContent(docinfoUrl);

      docinfoParser.parse(new InputSource(new StringReader(docInfoStr)));

      Hashtable docinfoHash = dih.getDocInfo();

      // Get doicd owner

      String user = (String)docinfoHash.get("user_owner");

      // Get docid name (such as acl or dataset)

      String docName = (String)docinfoHash.get("docname");

      // Get doc type (eml public id)

      String docType = (String)docinfoHash.get("doctype");

      // Get docid home sever. it might be different to remoteserver

      // becuause of hub feature

      String docHomeServer = (String)docinfoHash.get("home_server");

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

      //docid should include rev number too

      /*String accnum=docId+util.getOption("accNumSeparator")+

                                              (String)docinfoHash.get("rev");*/

      String datafilePath = util.getOption("datafilepath");

      // Get data file content

      String readDataURLString = "https://" + remoteserver + "?server="+

                                        util.getLocalReplicationServerName()+

                                            "&action=readdata&docid="+accNumber;

      readDataURLString = MetaCatUtil.replaceWhiteSpaceForURL(readDataURLString);

      URL u = new URL(readDataURLString);

      InputStream input = u.openStream();

      //register data file into xml_documents table and wite data file

      //into file system

      if ( input != null)

      {

        DocumentImpl.writeDataFileInReplication(input,

                                                datafilePath,

                                                docName,docType,

                                                accNumber, user,

                                                docHomeServer,

                                                remoteserver,

                                                tableName,

                                                true, //true means timed replication

                                                createdDate,

                                                updatedDate);

        logMetacat.info("Successfully to write datafile " + accNumber);

        MetacatReplication.replLog("wrote datafile " + accNumber + " from " +

                                    remoteserver);

      }//if

      else

      {

         logMetacat.info("Couldn't open the data file: " + accNumber);

         throw new Exception("Couldn't open the data file: " + accNumber);

      }//else

    }//try

    catch(Exception e)

    {

      MetacatReplication.replErrorLog("Failed to try wrote datafile " + accNumber +

                                      " because " +e.getMessage());

      logMetacat.error("Failed to try wrote datafile " + accNumber +

                                      " because " +e.getMessage());

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* Handle delete single document*/

  private void handleDeleteSingleDocument(String docId, String notifyServer)

               throws Exception

  {

    logMetacat.info("Try delete doc: "+docId);

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

    {

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.handleDeleteSingleDoc");

      serialNumber=dbConn.getCheckOutSerialNumber();

      if(!alreadyDeleted(docId))

      {

         //because delete method docid should have rev number

         //so we just add one for it. This rev number is no sence.

         String accnum=docId+util.getOption("accNumSeparator")+"1";

         //System.out.println("accnum: "+accnum);

         DocumentImpl.delete(accnum, null, null, notifyServer);

         logMetacat.info("Successfully deleted doc " + docId);

         MetacatReplication.replLog("Doc " + docId + " deleted");

      }

    }//try

    catch(Exception e)

    {

      MetacatReplication.replErrorLog("Failed to delete doc " + docId +

                                      " in db because " +e.getMessage());

      logMetacat.error("Failed to delete doc " + docId +

                                 " in db because because " + e.getMessage());

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* Handle updateLastCheckTimForSingleServer*/

  private void updateLastCheckTimeForSingleServer(ReplicationServer repServer)

                                                  throws Exception

  {

    String server = repServer.getServerName();

    DBConnection dbConn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    try

    {

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

             getDBConnection("ReplicationHandler.updateLastCheckTimeForServer");

      serialNumber=dbConn.getCheckOutSerialNumber();

      logMetacat.info("Try to update last_check for server: "+server);

      // Get time from remote server

      URL dateurl = new URL("https://" + server + "?server="+

      util.getLocalReplicationServerName()+"&action=gettime");

      String datexml = MetacatReplication.getURLContent(dateurl);

      logMetacat.info("datexml: "+datexml);

      if (datexml!=null && !datexml.equals(""))

      {

         String datestr = datexml.substring(11, datexml.indexOf('<', 11));

         StringBuffer sql = new StringBuffer();

         /*sql.append("update xml_replication set last_checked = to_date('");

         sql.append(datestr).append("', 'YY-MM-DD HH24:MI:SS') where ");

         sql.append("server like '").append(server).append("'");*/

         sql.append("update xml_replication set last_checked = ");

         sql.append(dbAdapter.toDate(datestr, "MM/DD/YY HH24:MI:SS"));

         sql.append(" where server like '").append(server).append("'");

         pstmt = dbConn.prepareStatement(sql.toString());

         pstmt.executeUpdate();

         dbConn.commit();

         pstmt.close();

         logMetacat.info("last_checked updated to "+datestr+" on "

                                      + server);

      }//if

      else

      {

         logMetacat.info("Failed to update last_checked for server "  +

                                  server + " in db because couldn't get time "

                                  );

         throw new Exception("Couldn't get time for server "+ server);

      }

    }//try

    catch(Exception e)

    {

      logMetacat.error("Failed to update last_checked for server " +

                                server + " in db because because " +

                                e.getMessage());

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /**

   * updates xml_catalog with entries from other servers.

   */

  private void updateCatalog()

  {

    logMetacat.info("Start of updateCatalog");

    // ReplicationServer object in server list

    ReplicationServer replServer = null;

    PreparedStatement pstmt = null;

    String server = null;

    // Go through each ReplicationServer object in sererlist

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

    {

      Vector remoteCatalog = new Vector();

      Vector publicId = new Vector();

      try

      {

        // Get ReplicationServer object from server list

        replServer = serverList.serverAt(j);

        // Get server name from the ReplicationServer object

        server = replServer.getServerName();

        // Try to get catalog

        URL u = new URL("https://" + server + "?server="+

        util.getLocalReplicationServerName()+"&action=getcatalog");

        logMetacat.info("sending message " + u.toString());

        String catxml = MetacatReplication.getURLContent(u);

        // Make sure there are not error, no empty string

        if (catxml.indexOf("error")!=-1 || catxml==null||catxml.equals(""))

        {

          throw new Exception("Couldn't get catalog list form server " +server);

        }

        logMetacat.info("catxml: " + catxml);

        CatalogMessageHandler cmh = new CatalogMessageHandler();

        XMLReader catparser = initParser(cmh);

        catparser.parse(new InputSource(new StringReader(catxml)));

        //parse the returned catalog xml and put it into a vector

        remoteCatalog = cmh.getCatalogVect();

        // Makse sure remoteCatalog is not empty

        if (remoteCatalog.isEmpty())

        {

          throw new Exception("Couldn't get catalog list form server " +server);

        }

        String localcatxml = MetacatReplication.getCatalogXML();

        // Make sure local catalog is no empty

        if (localcatxml==null||localcatxml.equals(""))

        {

          throw new Exception("Couldn't get catalog list form server " +server);

        }

        cmh = new CatalogMessageHandler();

        catparser = initParser(cmh);

        catparser.parse(new InputSource(new StringReader(localcatxml)));

        Vector localCatalog = cmh.getCatalogVect();

        //now we have the catalog from the remote server and this local server

        //we now need to compare the two and merge the differences.

        //the comparison is base on the public_id fields which is the 4th

        //entry in each row vector.

        publicId = new Vector();

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

        {

          Vector v = new Vector((Vector)localCatalog.elementAt(i));

          logMetacat.info("v1: " + v.toString());

          publicId.add(new String((String)v.elementAt(3)));

          //System.out.println("adding " + (String)v.elementAt(3));

        }

      }//try

      catch (Exception e)

      {

        MetacatReplication.replErrorLog("Failed to update catalog for server "+

                                    server + " because " +e.getMessage());

        logMetacat.error("Failed to update catalog for server "+

                                    server + " because " +e.getMessage());

      }//catch

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

      {

         // DConnection

        DBConnection dbConn = null;

        // DBConnection checkout serial number

        int serialNumber = -1;

        try

        {

            dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.updateCatalog");

            serialNumber=dbConn.getCheckOutSerialNumber();

            Vector v = (Vector)remoteCatalog.elementAt(i);

            //System.out.println("v2: " + v.toString());

            //System.out.println("i: " + i);

            //System.out.println("remoteCatalog.size(): " + remoteCatalog.size());

            //System.out.println("publicID: " + publicId.toString());

            logMetacat.info

                              ("v.elementAt(3): " + (String)v.elementAt(3));

           if(!publicId.contains(v.elementAt(3)))

           { //so we don't have this public id in our local table so we need to

             //add it.

             //System.out.println("in if");

             StringBuffer sql = new StringBuffer();

             sql.append("insert into xml_catalog (entry_type, source_doctype, ");

             sql.append("target_doctype, public_id, system_id) values (?,?,?,");

             sql.append("?,?)");

             //System.out.println("sql: " + sql.toString());

             pstmt = dbConn.prepareStatement(sql.toString());

             pstmt.setString(1, (String)v.elementAt(0));

             pstmt.setString(2, (String)v.elementAt(1));

             pstmt.setString(3, (String)v.elementAt(2));

             pstmt.setString(4, (String)v.elementAt(3));

             pstmt.setString(5, (String)v.elementAt(4));

             pstmt.execute();

             pstmt.close();

             MetacatReplication.replLog("Success fully to insert new publicid "+

                               (String)v.elementAt(3) + " from server"+server);

             logMetacat.info("Success fully to insert new publicid "+

                             (String)v.elementAt(3) + " from server" +server);

           }

        }

        catch(Exception e)

        {

           MetacatReplication.replErrorLog("Failed to update catalog for server "+

                                    server + " because " +e.getMessage());

           logMetacat.error("Failed to update catalog for server "+

                                    server + " because " +e.getMessage());

        }//catch

        finally

        {

           DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }//finall

      }//for remote catalog

    }//for server list

    logMetacat.info("End of updateCatalog");

  }

  /**

   * Method that returns true if docid has already been "deleted" from metacat.

   * This method really implements a truth table for deleted documents

   * The table is (a docid in one of the tables is represented by the X):

   * xml_docs      xml_revs      deleted?

   * ------------------------------------

   *   X             X             FALSE

   *   X             _             FALSE

   *   _             X             TRUE

   *   _             _             TRUE

   */

  private static boolean alreadyDeleted(String docid) throws Exception

  {

    DBConnection dbConn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.alreadyDeleted");

      serialNumber=dbConn.getCheckOutSerialNumber();

      boolean xml_docs = false;

      boolean xml_revs = false;

      StringBuffer sb = new StringBuffer();

      sb.append("select docid from xml_revisions where docid like '");

      sb.append(docid).append("'");

      pstmt = dbConn.prepareStatement(sb.toString());

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      if(tablehasrows)

      {

        xml_revs = true;

      }

      sb = new StringBuffer();

      sb.append("select docid from xml_documents where docid like '");

      sb.append(docid).append("'");

      pstmt.close();

      pstmt = dbConn.prepareStatement(sb.toString());

      //increase usage count

      dbConn.increaseUsageCount(1);

      pstmt.execute();

      rs = pstmt.getResultSet();

      tablehasrows = rs.next();

      pstmt.close();

      if(tablehasrows)

      {

        xml_docs = true;

      }

      if(xml_docs && xml_revs)

      {

        return false;

      }

      else if(xml_docs && !xml_revs)

      {

        return false;

      }

      else if(!xml_docs && xml_revs)

      {

        return true;

      }

      else if(!xml_docs && !xml_revs)

      {

        return true;

      }

    }

    catch(Exception e)

    {

      logMetacat.error("error in ReplicationHandler.alreadyDeleted: " +

                          e.getMessage());

      throw e;

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException ee)

      {

        logMetacat.error("Error in replicationHandler.alreadyDeleted "+

                          "to close pstmt: "+ee.getMessage());

        throw ee;

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

    return false;

  }

  /**

   * Method to initialize the message parser

   */

  public static XMLReader initParser(DefaultHandler dh)

          throws Exception

  {

    XMLReader parser = null;

    try {

      ContentHandler chandler = dh;

      // Get an instance of the parser

      MetaCatUtil util = new MetaCatUtil();

      String parserName = util.getOption("saxparser");

      parser = XMLReaderFactory.createXMLReader(parserName);

      // Turn off validation

      parser.setFeature("http://xml.org/sax/features/validation", false);

      parser.setContentHandler((ContentHandler)chandler);

      parser.setErrorHandler((ErrorHandler)chandler);

    } catch (Exception e) {

      throw e;

    }

    return parser;

  }

  /**

   * This method will combinate given time string(in short format) to

   * current date. If the given time (e.g 10:00 AM) passed the current time

   * (e.g 2:00 PM Aug 21, 2005), then the time will set to second day,

   * 10:00 AM Aug 22, 2005. If the given time (e.g 10:00 AM) haven't passed

   * the current time (e.g 8:00 AM Aug 21, 2005) The time will set to be

   * 10:00 AM Aug 21, 2005.

   * @param givenTime  the format should be "10:00 AM " or "2:00 PM"

   * @return

   * @throws Exception

   */

  public static Date combinateCurrentDateAndGivenTime(String givenTime) throws Exception

  {

     Date givenDate = parseTime(givenTime);

     Date newDate = null;

     Date now = new Date();

     String currentTimeString = getTimeString(now);

     Date currentTime = parseTime(currentTimeString); 

     if ( currentTime.getTime() >= givenDate.getTime())

     {

        logMetacat.info("Today already pass the given time, we should set it as tomorrow");

        String dateAndTime = getDateString(now) + " " + givenTime;

        Date combinationDate = parseDateTime(dateAndTime);

        // new date should plus 24 hours to make is the second day

        newDate = new Date(combinationDate.getTime()+24*3600*1000);

     }

     else

     {

         logMetacat.info("Today haven't pass the given time, we should it as today");

         String dateAndTime = getDateString(now) + " " + givenTime;

         newDate = parseDateTime(dateAndTime);

     }

     logMetacat.warn("final setting time is "+ newDate.toString());

     return newDate;

  }

  /*

   * parse a given string to Time in short format.

   * For example, given time is 10:00 AM, the date will be return as

   * Jan 1 1970, 10:00 AM

   */

  private static Date parseTime(String timeString) throws Exception

  {

    DateFormat format = DateFormat.getTimeInstance(DateFormat.SHORT);

    Date time = format.parse(timeString); 

    logMetacat.info("Date string is after parse a time string "

                              +time.toString());

    return time;

  }

  /*