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

{

  Hashtable serverList = new Hashtable();

  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

    {

      //{ //this connection is prone to error for some reason so we

      //}

      //catch(SQLException sqle)

      //{

          conn = util.openDBConnection();

        }

        catch(SQLException sqlee)

        {

          try

          {

            conn = util.openDBConnection();

          }

          catch(SQLException sqleee)

                               //"ReplicationHandler.run: " +

                               //sqle.getMessage());

        //}

      serverList = buildServerList();

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

      {

        return;

      }

    }//try

    {

                                                    +e.getMessage(), 30);

    }//catch

  /**

   */

    /*

     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;

    /*try

    String server;

    String update;

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

    boolean tablehasrows;

    boolean flag=false;

    XMLReader parser;

    URL u;

    try

    {

                  getDBConnection("ReplicationHandler.update");

      serialNumber=dbConn.getCheckOutSerialNumber();

      keys = serverList.keys();

      while(keys.hasMoreElements())

      {

        server = (String)(keys.nextElement());

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

        {

          continue;

        }

      }

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

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

      {

        return;

      }

      { //check each server for updated files

        //System.out.println("parsing responses");

        parser.parse(new InputSource(

                     new StringReader(

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

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

        //in the local DB.

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

        {

          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;

          }

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

          pstmt.execute();

          rs = pstmt.getResultSet();

          tablehasrows = rs.next();

          if(tablehasrows)

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

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

            int localrev = rs.getInt(1);

            if(localrev == rev)

            {

              flag = 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;

          }

          if(flag && !dataFile)

            {

            MetaCatUtil.debugMessage(newxmldoc, 50);

            XMLReader docinfoParser = initParser(dih);

            //System.out.println("Sending message: " + docinfoUrl.toString());

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

            Hashtable docinfoHash = dih.getDocInfo();

            //int serverCode = MetacatReplication.getServerCode(docServer);

            //docid should include rev number too

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

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

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

            {

                              null,  /* the dtd text */

              dbConn.increaseUsageCount(1);

                                         docServer);

                                 docServer);*/

            catch(Exception e)

            {

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

          if(flag && dataFile

                   && (util.getOption("replicationacceptdata")).equals("on"))

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

            //String newxmldoc = MetacatReplication.getURLContent(u);

            DocInfoHandler dih = new DocInfoHandler();

            XMLReader docinfoParser = initParser(dih);

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

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

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

            //System.out.println("Sending message: " + docinfoUrl.toString());

            String docInfoStr = MetacatReplication.getURLContent(docinfoUrl);

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

            Hashtable docinfoHash = dih.getDocInfo();

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

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

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

            //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://" + docServer + "?server="+

                                        util.getLocalReplicationServerName()+

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

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

            try

            {

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

              //into file system

              {

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

                                         docServer);

              else

              {

                                 docServer);*/

            }

            catch(Exception e)

            {

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

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

            }

          }//for datafile

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

        while(keys.hasMoreElements())

        {

          server = (String)(keys.nextElement());

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

      }//for

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

  /**

   */

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    {

      {

      }

      catch(SQLException sqle)

      {

        try

        {

          conn = util.openDBConnection();

        }

        catch(SQLException sqlee)

        {

          try

          {

            conn = util.openDBConnection();

          }

          catch(SQLException sqleee)

          {

            System.out.println("error getting db connection in " +

                               "ReplicationHandler.update: " +

                               sqleee.getMessage());

          }

        }

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.updateCatalog");

      serialNumber=dbConn.getCheckOutSerialNumber();

      Enumeration keys = serverList.keys();

      while(keys.hasMoreElements())

      { //go through each server

        server = (String)(keys.nextElement());

        //System.out.println("sending message " + u.toString());

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

        String localcatxml = MetacatReplication.getCatalogXML();

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

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

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

    {

      {

      }//try

      catch (SQLException ee)

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

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finall

  /**

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

   *   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

  }

  /**

   * "UPDATE" if it is, "INSERT" if it isn't

   */

  private static String getAction(String docid)

  {

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    {

                  getDBConnection("ReplicationHandler.getAction");

      serialNumber=dbConn.getCheckOutSerialNumber();

      //MetaCatUtil util = new MetaCatUtil();

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

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

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

      ResultSet rs = pstmt.getResultSet();

      if(rs.next())

      {

      }

      else

      {

      }

    }

    catch(Exception e)

    {

      System.out.println("error in replicationHandler.getAction: " +

                          e.getMessage());

    }

    {

      try