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-02-04 15:51:25 -0800 (Tue, 04 Feb 2003) $'

 * '$Revision: 1387 $'

 *

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

    */

    DBConnection dbConn = null;

    int serialNumber = -1;

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

    PreparedStatement pstmt = null;

    ResultSet rs;

    boolean tablehasrows;

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

    boolean dataFile=false;

    String action = new String();

    XMLReader parser;

    URL u;

    try

    {

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.update");

      serialNumber=dbConn.getCheckOutSerialNumber();

      MetaCatUtil.debugMessage("init parser", 50);

      parser = initParser(message);

      //Check for every server in server list

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

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

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

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

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

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

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

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

        {

          continue;

        }

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

      {

        return;

      }

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

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

        //v is the list of updated documents

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

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

        //d is the list of deleted documents

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

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

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

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

        //check the revs in u to see if there are any newer ones than

        //in the local DB.

        for(int j=0; j<v.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)(v.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);

          // Choose revision number from local host

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

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

          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 might be out of date.

            int localrev = rs.getInt(1);

            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;

            }

          }

          else

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

            action = "INSERT";

            flag = true;

          }

          // Close result set

          rs.close();

          // Close preparedstatement

          pstmt.close();

          // this is non-data file

          if(flag && !dataFile)

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

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

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

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

            // Get docid content

            String newxmldoc = MetacatReplication.getURLContent(u);

            // If couldn't get skip it

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

            {

              continue;

            }

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

            MetaCatUtil.debugMessage(newxmldoc, 50);

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

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

            //docid should include rev number too

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

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

            try

            {

              // Write the document into local host

              String newDocid = DocumentImplWrapper.writeReplication(dbConn, 

                              new StringReader(newxmldoc),

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

                              null,  /* the dtd text */

                              action, 

                              accnum, 

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

                              null, /* null for groups[] */

                              docHomeServer, 

                              remoteServer);

              //increase usage

              dbConn.increaseUsageCount(1);

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

                                         remoteServer);

              /*System.out.println("wrote doc " + docid + " from " + 

                                 docServer);*/

            }

            catch(Exception e)

            {

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

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

            }

          }//if for non-data file

           // this is for data file

          if(flag && dataFile)

          { 

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

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

            //System.out.println("updating doc: " + docid +" action: "+ action);

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

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

                                        util.getLocalReplicationServerName()+

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

            try

            {

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

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

                                         remoteServer);

              }//if

              else

              {

                // If get null, skip it

                continue;

              }//else

            }//try

            catch(Exception e)

            {

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

                                 "ReplicationHandler.update: " + docid +

                                 ": " + e.getMessage());

            }//catch

          }//for datafile

        }//for update docs

        //handle deleted docs

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

        { //delete the deleted documents;

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

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

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

            MetacatReplication.replLog("doc " + docid + " deleted");

          }

        }//for delete docs

      }//for

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

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

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

          String datexml = MetacatReplication.getURLContent(dateurl);

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

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

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

            //increase usage count

            dbConn.increaseUsageCount(1);

            pstmt.executeUpdate();

            dbConn.commit();

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

                                      + server, 45);

          }//if

      }//for

    }//try

    catch(Exception e)

    {

      /*System.out.println("error in ReplicationHandler.update: " + 

                          e.getMessage());*/

      e.printStackTrace(System.out);

    }

    finally

    {

      try

      {

          pstmt.close();

      }//try

      catch(Exception ee) 

      {

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

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

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

  }//update

  /**

   * updates xml_catalog with entries from other servers.

   */

  private void updateCatalog()

  {

    // DConnection

    DBConnection dbConn = null;

    // DBConnection checkout serial number

    int serialNumber = -1;

    // ReplicationServer object in server list

    ReplicationServer replServer = null;

    PreparedStatement pstmt = null;

    try

    {

      dbConn=DBConnectionPool.

                  getDBConnection("ReplicationHandler.updateCatalog");

      serialNumber=dbConn.getCheckOutSerialNumber();

      String server;

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

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

        {

          continue;

        }

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

        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

        Vector remoteCatalog = cmh.getCatalogVect();

        // Makse sure remoteCatalog is not empty

        if (remoteCatalog.isEmpty())

        {

          continue;

        }

        String localcatxml = MetacatReplication.getCatalogXML();

        // Make sure local catalog is no empty

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

        {

          continue;

        }

        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.

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

        }

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

        {

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

            //increase usage count 1

            dbConn.increaseUsageCount(1);

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

          }

        }

      }

    }

    catch(Exception e)

    {

      System.out.println("error in ReplicationHandler.updateCatalog: " + 

                          e.getMessage());

      e.printStackTrace(System.out);

    }//catch

    finally

    {

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finall

  }

  /**

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

  {

    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)

    {

      System.out.println("error in ReplicationHandler.alreadyDeleted: " + 

                          e.getMessage());

      e.printStackTrace(System.out);

    }

    finally

    {

      try

      {

        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

    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;

  }

}