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

 *     '$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.sql.*;

import java.util.*;

import java.lang.Thread;

import java.io.*;

import java.net.*;

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;

 * 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

{

  public ReplicationHandler(PrintWriter o)

  {

    this.out = o;

  {

    this.out = o;

    this.serverCheckCode = serverCheckCode;

   * 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==null||serverList.isEmpty())

      {

        return;

      }

      update();

    }//try

    {

                                                    +e.getMessage(), 30);

  /**

   */

    /*

     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)

    */

    int serialNumber = -1;

    ReplicationServer replServer = null; // Variable to store the

                                        // ReplicationServer got from

                                        // Server list

    String server; // Variable to store server name

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

    boolean tablehasrows;

    XMLReader parser;

    URL u;

    try

    {

                  getDBConnection("ReplicationHandler.update");

      serialNumber=dbConn.getCheckOutSerialNumber();

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

        replServer = serverList.serverAt(i);

        // Get server name from ReplicationServer object

        server = replServer.getServerName();

        // Get information from remote server

        String result = null;

        try

        {

          result = MetacatReplication.getURLContent(u);

        }//try

        catch (Exception e)

        {

          MetaCatUtil.debugMessage("Error in get docid information from "+

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

          continue;

        }//catch

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

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

        {

          continue;

        }

      }

      {

        return;

      }

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

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

      { //check each server for updated files

        parser.parse(new InputSource(

                     new StringReader(

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

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

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

        //in the local DB.

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

        {

          dataFile=false;

          //w is information for one document, information contain

          //docid, rev, server or datafile.

          //If it has, this document is data file

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

          {

            dataFile=true;

          }

          // the new hub feature

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

          pstmt = dbConn.prepareStatement("select rev from xml_documents where "

                                            + "docid like '" + docid + "'");

          rs = pstmt.getResultSet();

          tablehasrows = rs.next();

          if(tablehasrows)

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

            if(localrev == rev)

            {

              // update and flag set false

            }

            else if(localrev < rev)

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

              action = "UPDATE";

              flag = true;

            }

          }

          else

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

            action = "INSERT";

            flag = true;

          }

          rs.close();

          // Close preparedstatement

          pstmt.close();

          if(flag && !dataFile)

            {

            MetaCatUtil.debugMessage(newxmldoc, 50);

            // Try get the docid info from remote server

            XMLReader docinfoParser = initParser(dih);

                                                  docinfoUrl.toString(), 50);

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

            Hashtable docinfoHash = dih.getDocInfo();

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

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

            {

                              null,  /* the dtd text */

              dbConn.increaseUsageCount(1);

                                 docServer);*/

            catch(Exception e)

            {

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

          if(flag && dataFile)

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

            // Try get docid info from remote server

            XMLReader docinfoParser = initParser(dih);

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

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

            Hashtable docinfoHash = dih.getDocInfo();

            // becuause of hub feature

            //docid should include rev number too

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

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

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

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

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

            {

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

              //into file system

              {

                                                        datafilePath,

                                                        docName,docType,

                                                        accnum, user,

                                                        docHomeServer,

                                                        remoteServer);

                                         remoteServer);

              }//if

              {

            }//try

            {

              System.out.println("error writing document in " +

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

        }//for update docs

        { //delete the deleted documents;

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

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

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

      //updated last_checked

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

          // Get time from remote server

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

            //increase usage count

            dbConn.increaseUsageCount(1);

                                      + server, 45);

          }//if

    }//try

    {

                          e.getMessage());*/

    }

    {

      try

      {

          pstmt.close();

      catch(Exception ee)

      {

        MetaCatUtil.debugMessage("Error in ReplicationHandler.update to close"+

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

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

  }//update

  /**

   */

    ReplicationServer replServer = null;

    {

                  getDBConnection("ReplicationHandler.updateCatalog");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // Go through each ReplicationServer object in sererlist

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

      {

        // Get ReplicationServer object from server list

        replServer = serverList.serverAt(j);

        // Get server name from the ReplicationServer object

        server = replServer.getServerName();

        // Try to get catalog

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

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

        {

          continue;

        }

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

        XMLReader catparser = initParser(cmh);

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

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

        Vector remoteCatalog = cmh.getCatalogVect();

        if (remoteCatalog.isEmpty())

        {

          continue;

        }

        // Make sure local catalog is no empty

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

        {

          continue;

        }

        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.

        Vector publicId = new Vector();

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

        {

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

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

        {

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

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

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

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

            //add it.

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

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

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

            //increase usage count 1

            dbConn.increaseUsageCount(1);

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

        }

      }

    catch(Exception e)

    {

                          e.getMessage());

    finally

    {

  /**

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

   *   X             X             FALSE

   *   X             _             FALSE

   *   _             X             TRUE

   *   _             _             TRUE

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    {

                  getDBConnection("ReplicationHandler.alreadyDeleted");

      serialNumber=dbConn.getCheckOutSerialNumber();

      boolean xml_revs = false;

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      if(tablehasrows)

      {

      }

      sb = new StringBuffer();

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

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

      //increase usage count

      dbConn.increaseUsageCount(1);

      rs = pstmt.getResultSet();

      tablehasrows = rs.next();

      {

        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;

      }

    catch(Exception e)

    {

                          e.getMessage());

    }

    {

      {

        pstmt.close();

      }//try

      catch (SQLException ee)

      {

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

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

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

  }

  /**

   */

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