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: 2003-04-18 20:33:22 -0700 (Fri, 18 Apr 2003) $'

 * '$Revision: 1585 $'

 *

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

import java.lang.Thread; 

import java.io.*;

import java.net.*;

import java.text.*;

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;

  public ReplicationHandler(PrintWriter o)

  {

    this.out = o;

    serverList = new ReplicationServerList();

  }

  public ReplicationHandler(PrintWriter o, 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)

    {

      MetaCatUtil.debugMessage("Error in replicationHandler.run():"

                                                    +e.getMessage(), 30);

      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; // Variable to store server name

    String update;

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

    boolean flag=false; // If a document need to update

    boolean dataFile=false;

    String action = new String();

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

      MetaCatUtil.debugMessage("Failed to replicate becaue couldn't " +

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

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

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

          MetaCatUtil.debugMessage("Sending infomation " +u.toString(), 50);

          result = MetacatReplication.getURLContent(u);

        }

        catch (Exception e)

        {

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

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

          MetaCatUtil.debugMessage( "Failed to get updated doc list "+

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

          continue;

        }

        MetaCatUtil.debugMessage("docid: "+server+" "+result, 50);

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

        if (result.indexOf("error")!=-1)

        {

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

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

          MetaCatUtil.debugMessage( "Failed to get updated doc list "+

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

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

        MetaCatUtil.debugMessage( "No updated doc list for "+

                           "every server and failed to replicate", 30);

        return;

    }

    MetaCatUtil.debugMessage("Responses from remote metacat about updated "+

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

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

          MetaCatUtil.debugMessage("Couldn't parse one responses "+

                                   "because "+ e.getMessage(), 30);

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

        MetaCatUtil.debugMessage("Update vector size: "+ updateList.size(), 40);

        MetaCatUtil.debugMessage("Delete vector size: "+ deleteList.size(),40);

        // go though every element in updated document vector

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

        {

          //initial dataFile is false

          dataFile=false;

          //w is information for one document, information contain

          //docid, rev, server or datafile.

          Vector w = new Vector((Vector)(updateList.elementAt(j)));

          //Check if the vector w contain "datafile"

          //If it has, this document is data file

          if (w.contains((String)util.getOption("datafileflag")))

          {

            dataFile=true;

          }

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

          // Get docid

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

          MetaCatUtil.debugMessage("docid: " + docid, 40);

          // Get revision number

          int rev = Integer.parseInt((String)w.elementAt(1));

          MetaCatUtil.debugMessage("rev: " + rev, 40);

          // Get remote server name (it is may not be doc homeserver because

          // the new hub feature

          String remoteServer = (String)w.elementAt(2);

          // compare the update rev and local rev to see what need happen

          int localrev = -1;

          try

          {

            localrev = DocumentImpl.getLatestRevisionNumber(docid);

          }

          catch (SQLException e)

          {

            MetaCatUtil.debugMessage("Local rev for docid "+ docid + " could not "+ 

                                   " be found because " + e.getMessage(), 45);

            MetacatReplication.replErrorLog("Docid "+ docid + " could not be "+

                    "written because error happend to find it's local revision");

            continue;

          }

          MetaCatUtil.debugMessage("Local rev for docid "+ docid + " is "+ 

                                  localrev, 45);

          //check the revs for an update because this document is in the

          //local DB, it might be out of date.

          if (localrev == -1)

          {

            //insert this document as new because it is not in the local DB

            action = "INSERT";

            flag = true;

          }

          else

          {

            if(localrev == rev)

            {

              // Local meatacat has the same rev to remote host, don't need 

              // update and flag set false

              flag = false;

            }

            else if(localrev < rev)

            {

              //this document needs to be updated so send an read request

              action = "UPDATE";

              flag = true;

            }

          }

          // this is non-data file

          if(flag && !dataFile)

          { 

            try

            {

              handleSingleXMLDocument(remoteServer, action, docid);

            }

            catch(Exception e)

            {

              // skip this document

              continue;

            }

          }//if for non-data file

           // this is for data file

          if(flag && dataFile)

          { 

            try

            {

              handleSingleDataFile(remoteServer, action, docid);

            }

            catch(Exception e)

            {

              // skip this datafile

              continue;

            }

          }//for datafile

        }//for update docs

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

          }

          catch (Exception ee)

          {

            continue;

          }

        }//for delete docs

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

               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

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

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

      // Get docid content

      String newxmldoc = MetacatReplication.getURLContent(u);

      // If couldn't get skip it

      if ( newxmldoc.indexOf("error")!= -1)

      {

         throw new Exception(newxmldoc);

      }

      MetaCatUtil.debugMessage("xml documnet:", 45);

      MetaCatUtil.debugMessage(newxmldoc, 45);

      // Try get the docid info from remote server

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = initParser(dih);

      URL docinfoUrl = new URL("https://" + remoteserver + 

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

                       "&action=getdocumentinfo&docid="+docId);

      MetaCatUtil.debugMessage("Sending message: " + 

                                                  docinfoUrl.toString(), 45);

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

      MetaCatUtil.debugMessage("doc home server in repl: "+docHomeServer, 45);

      //docid should include rev number too

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

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

      MetaCatUtil.debugMessage("docid in repl: "+accnum, 45);

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

      MetaCatUtil.debugMessage("doctype in repl: "+docType, 45);

      String parserBase = null;

      // this for eml2 and we need user eml2 parser

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

      {

         parserBase = DocumentImpl.EML2;

      }

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

                              accnum, 

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

                              null, /* null for groups[] */

                              docHomeServer, 

                              remoteserver);

      MetaCatUtil.debugMessage("Successfully replicated doc " + accnum, 35);

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

                                         remoteserver);

    }//try      

    catch(Exception e)

    {

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

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

      MetaCatUtil.debugMessage("Failed to write doc " + docId +

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

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* Handle replicate single xml document*/

  private void handleSingleDataFile(String remoteserver, String actions, 

                                    String docId) 

               throws Exception

  {

    MetaCatUtil.debugMessage("Try to replicate data file: "+docId, 40);

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

      URL docinfoUrl = new URL("https://" + remoteserver + 

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

                  "&action=getdocumentinfo&docid="+docId);

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

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

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

                                        util.getLocalReplicationServerName()+

                                            "&action=readdata&docid="+accnum);

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

      //into file system

      if (u.openStream() != null)

      {

         DocumentImpl.writeDataFileInReplication(u.openStream(), 

                                                        datafilePath, 

                                                        docName,docType, 

                                                        accnum, user,

                                                        docHomeServer,

                                                        remoteserver);

        MetaCatUtil.debugMessage("Successfully to write datafile " + docId, 30);      

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

                                    remoteserver);

      }//if

      else

      {

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

      }//else

    }//try      

    catch(Exception e)

    {

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

                                      " because " +e.getMessage());

      MetaCatUtil.debugMessage("Failed to try wrote datafile " + docId +

                                      " because " +e.getMessage(), 30);

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /* Handle delete single document*/

  private void handleDeleteSingleDocument(String docId) 

               throws Exception

  {

    MetaCatUtil.debugMessage("Try delete doc: "+docId, 40);

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

         MetaCatUtil.debugMessage("Successfully deleted doc " + docId, 30); 

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

      }

    }//try      

    catch(Exception e)

    {

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

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

      MetaCatUtil.debugMessage("Failed to delete doc " + docId +

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

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

      MetaCatUtil.debugMessage("Try to update last_check for server: "+server, 40);

      // Get time from remote server

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

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

      String datexml = MetacatReplication.getURLContent(dateurl);

      MetaCatUtil.debugMessage("datexml: "+datexml, 45);

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

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

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

         pstmt.executeUpdate();

         dbConn.commit();

         pstmt.close();

         MetaCatUtil.debugMessage("last_checked updated to "+datestr+" on " 

                                      + server, 45);

      }//if

      else

      {

         MetaCatUtil.debugMessage("Failed to update last_checked for server "  + 

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

                                  , 30);

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

      }

    }//try      

    catch(Exception e)

    {

      MetaCatUtil.debugMessage("Failed to update last_checked for server " + 

                                server + " in db because because " +

                                e.getMessage(), 30);

      throw e;

    }

    finally

    {

       //return DBConnection

       DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /**

   * updates xml_catalog with entries from other servers.

   */

  private void updateCatalog()

  {

    MetaCatUtil.debugMessage("Start of updateCatalog", 35 );

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

        MetaCatUtil.debugMessage("sending message " + u.toString(), 50);

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

        }

        MetaCatUtil.debugMessage("catxml: " + catxml, 40);

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

          MetaCatUtil.debugMessage("v1: " + v.toString(), 50);

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

        MetaCatUtil.debugMessage("Failed to update catalog for server "+

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

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

            MetaCatUtil.debugMessage

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

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

             MetaCatUtil.debugMessage("Success fully to insert new publicid "+

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

           }

        }

        catch(Exception e)

        {

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

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

           MetaCatUtil.debugMessage("Failed to update catalog for server "+

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

        }//catch

        finally

        {

           DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }//finall

      }//for remote catalog

    }//for server list

    MetaCatUtil.debugMessage("End of updateCatalog", 35);

  }

  /**

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

    {

      MetaCatUtil.debugMessage("error in ReplicationHandler.alreadyDeleted: " + 

                          e.getMessage(), 30);

      throw e;

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException ee)

      {

        MetaCatUtil.debugMessage("Error in replicationHandler.alreadyDeleted "+

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

        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;

    }