Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements replication for metacat

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *    Release: @release@

 *

 *   '$Author: berkley $'

 *     '$Date: 2000-11-28 08:30:59 -0800 (Tue, 28 Nov 2000) $'

 * '$Revision: 568 $'

 */

package edu.ucsb.nceas.metacat;

import java.util.*;

import java.io.*;

import java.sql.*;

import java.net.*;

import java.lang.*;

import java.text.*;

import javax.servlet.*;

import javax.servlet.http.*;

import oracle.xml.parser.v2.*;

import org.xml.sax.*;

public class MetacatReplication extends HttpServlet implements Runnable

{  

  private String deltaT;

  Timer replicationDaemon;

  private static MetaCatUtil util = new MetaCatUtil();

  private Vector fileLocks = new Vector();

  private Thread lockThread = null;

  /**

   * Initialize the servlet by creating appropriate database connections

   */

  public void init(ServletConfig config) throws ServletException 

  {

    //initialize db connections to handle any update requests

    MetaCatUtil util = new MetaCatUtil();

    deltaT = util.getOption("deltaT");

    //break off a thread to do the delta-T check

    replicationDaemon = new Timer(true);

    //replicationDaemon.scheduleAtFixedRate(new replicationHandler(), 0, 

    //                                      new Integer(deltaT).intValue() * 1000);

    //System.out.println("timer scheduled at: " + new Integer(deltaT).intValue() 

    //                   + " seconds");

  }

  public void destroy() 

  {

    replicationDaemon.cancel();

    System.out.println("Replication daemon cancelled.");

  }

  public void doGet (HttpServletRequest request, HttpServletResponse response)

                     throws ServletException, IOException 

  {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  public void doPost(HttpServletRequest request, HttpServletResponse response)

                     throws ServletException, IOException 

  {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  private void handleGetOrPost(HttpServletRequest request, 

                               HttpServletResponse response) 

                               throws ServletException, IOException 

  {

    PrintWriter out = response.getWriter();

    Hashtable params = new Hashtable();

    Enumeration paramlist = request.getParameterNames();

    while (paramlist.hasMoreElements()) 

    {

      String name = (String)paramlist.nextElement();

      String[] value = request.getParameterValues(name);

      params.put(name, value);  

    }

    if(params.containsKey("action"))

    {

      if(((String[])params.get("action"))[0].equals("stop"))

      { //stop the replication server

        replicationDaemon.cancel();

        out.println("Replication Handler Stopped");

        System.out.println("Replication Handler Stopped");

      }

      else if(((String[])params.get("action"))[0].equals("start"))

      { //start the replication server

        int rate;

        if(params.containsKey("rate"))

        {

          rate = new Integer(

                 new String(((String[])params.get("rate"))[0])).intValue();

          if(rate < 30)

          {

            out.println("Replication deltaT rate cannot be less than 30!");

            rate = 1000;

          }

        }

        else

        {

          rate = 1000;

        }

        out.println("New rate is: " + rate + " seconds.");

        replicationDaemon.cancel();

        replicationDaemon = new Timer(true);

        replicationDaemon.scheduleAtFixedRate(new ReplicationHandler(out), 0, 

                                              rate * 1000);

        out.println("Replication Handler Started");

      }

      else if(((String[])params.get("action"))[0].equals("update"))

      { //request an update list from the server

        handleUpdateRequest(out, params, response);

      }

      else if(((String[])params.get("action"))[0].equals("read"))

      { //request a specific document from the server

        //note that this could be replaced by a call to metacatServlet

        //handleGetDocumentAction().

        handleGetDocumentRequest(out, params, response);

      }

      else if(((String[])params.get("action"))[0].equals("getlock"))

      {

        handleGetLockRequest(out, params, response);

      }

      else if(((String[])params.get("action"))[0].equals("getdocumentinfo"))

      {

        handleGetDocumentInfoRequest(out, params, response);

      }

      else if(((String[])params.get("action"))[0].equals("gettime"))

      {

        handleGetTimeRequest(out, params, response);

      }

    }

  }

  /**

   * Grants or denies a lock to a requesting host.

   * The servlet parameters of interrest are:

   * docid: the docid of the file the lock is being requested for

   * currentdate: the timestamp of the document on the remote server

   * 

   */

  private void handleGetLockRequest(PrintWriter out, Hashtable params,

                                    HttpServletResponse response)

  {

    java.util.Date remoteDate = new java.util.Date();

    java.util.Date localDate = new java.util.Date();

    try

    {

      Connection conn = util.openDBConnection();

      String docid = ((String[])params.get("docid"))[0];

System.out.println("docid: " + docid);

      String remoteDateStr = ((String[])params.get("updatedate"))[0];

      DocumentImpl requestDoc = new DocumentImpl(conn, docid);

      String localDateStr = requestDoc.getUpdateDate();

      SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

      ParsePosition pos = new ParsePosition(0);

      remoteDate = formatter.parse(remoteDateStr, pos);

      pos = new ParsePosition(0);

      localDate = formatter.parse(localDateStr, pos);

System.out.println("remotedate: " + remoteDate.toString());

System.out.println("localdate: " + localDate.toString());

      if(remoteDate.compareTo(localDate) >= 0)

      {

        if(!fileLocks.contains(docid))

        { //grant the lock

          fileLocks.add(0, docid); //insert at the beginning of the queue Vector

          //send a message back to the the remote host authorizing the insert

          out.println("<lockgranted><docid>" +docid+ "</docid></lockgranted>");

          lockThread = new Thread(this);

          lockThread.setPriority(Thread.MIN_PRIORITY);

          lockThread.start();

        }

        else

        { //deny the lock

          out.println("<filelocked><docid>" + docid + "</docid></filelocked>");

        }

      }

      else

      {//deny the lock.

        out.println("<outdatedfile><docid>" + docid + "</docid></filelocked>");

      }

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("error requesting file lock: " + e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

   * Sends all of the xml_documents information encoded in xml to a requestor

   */

  private void handleGetDocumentInfoRequest(PrintWriter out, Hashtable params, 

                                        HttpServletResponse response)

  {

    String docid = ((String[])(params.get("docid")))[0];

    StringBuffer sb = new StringBuffer();

    try

    {

      Connection conn = util.openDBConnection();

      DocumentImpl doc = new DocumentImpl(conn, docid);

      sb.append("<documentinfo><docid>").append(docid);

      sb.append("</docid><docname>").append(doc.getDocname());

      sb.append("</docname><doctype>").append(doc.getDoctype());

      sb.append("</doctype><doctitle>").append(doc.getDocTitle());

      sb.append("</doctitle><user_owner>").append(doc.getUserowner());

      sb.append("</user_owner><user_updated>").append(doc.getUserupdated());

      sb.append("</user_updated><public_access>").append(doc.getPublicaccess());

      sb.append("</public_access></documentinfo>");

      response.setContentType("text/xml");

      out.println(sb.toString());

      conn.close();

    }

    catch (Exception e)

    {

      System.out.println("error in metacatReplication.handlegetdocumentinforequest: " + 

      e.getMessage());

    }

  }

  /**

   * Sends a document to a remote host

   */

  private void handleGetDocumentRequest(PrintWriter out, Hashtable params, 

                                        HttpServletResponse response)

  {

    try

    {

      String docid = ((String[])(params.get("docid")))[0];

      System.out.println("incoming get request for document: " +

                         docid);

      Connection conn = util.openDBConnection();

      DocumentImpl di = new DocumentImpl(conn, docid);

      response.setContentType("text/xml");

      out.print(di.toString());

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("error getting document: " + e.getMessage());

    }

  }

  private void handleUpdateRequest(PrintWriter out, Hashtable params, 

                                   HttpServletResponse response)

  {

    System.out.println("incoming update request for dt/time " + 

                       ((String[])params.get("date"))[0] +

                       " from external metacat");

    response.setContentType("text/xml");

    StringBuffer returnXML = new StringBuffer();

    returnXML.append("<?xml version=\"1.0\"?><replication>");

    StringBuffer sql = new StringBuffer();

    String updateStr = ((String[])params.get("date"))[0];

    updateStr = updateStr.replace('+', ' ');

    //pseudo algorithm:

    ///////////////////////////////////////////////////////////////////////

    //get the date/time from the requestor, query the db for any documents

    //that have an update date later than the requested date and send

    //those docids back to the requestor.  If there are no newer documents

    //then send back a null message.

    ///////////////////////////////////////////////////////////////////////

    //Timestamp update = Timestamp.valueOf(updateStr);

    SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

    java.util.Date update = new java.util.Date();

    ParsePosition pos = new ParsePosition(0);

    update = formatter.parse(updateStr, pos);

    String dateString = formatter.format(update);

    sql.append("select docid, date_updated, server_location from ");

    sql.append("xml_documents where date_updated > ");

    sql.append("to_date('").append(dateString);

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

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

    //get any recently deleted documents

    StringBuffer delsql = new StringBuffer();

    delsql.append("select docid, date_updated, server_location from ");

    delsql.append("xml_revisions where docid not in (select docid from ");

    delsql.append("xml_documents) and date_updated > to_date('");

    delsql.append(dateString).append("','YY-MM-DD HH24:MI:SS')");

    try

    {

      Connection conn = util.openDBConnection();

      PreparedStatement pstmt = conn.prepareStatement(sql.toString());

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      //if a '1' should not represent localhost, add code here to query

      //xml_replication for the proper serverid number

      returnXML.append("<server>").append(util.getOption("server"));

      returnXML.append(util.getOption("replicationpath"));

      returnXML.append("</server><updates>");

      while(tablehasrows)

      {

        String docid = rs.getString(1);

        String dateUpdated = rs.getString(2);

        int serverCode = rs.getInt(3);

        if(serverCode == 1)

        { //check that this document is from this server.

          //servers only replicate their own documents!

          returnXML.append("<updatedDocument><docid>").append(docid);

          returnXML.append("</docid><date_updated>").append(dateUpdated);

          returnXML.append("</date_updated></updatedDocument>");

        }

        tablehasrows = rs.next();

      }

      pstmt = conn.prepareStatement(delsql.toString());

      pstmt.execute();

      rs = pstmt.getResultSet();

      tablehasrows = rs.next();

      while(tablehasrows)

      { //handle the deleted documents

        String docid = rs.getString(1);

        String dateUpdated = rs.getString(2);

        int serverCode = rs.getInt(3);

        if(serverCode == 1)

        {

          returnXML.append("<deletedDocument><docid>").append(docid);

          returnXML.append("</docid><date_updated>").append(dateUpdated);

          returnXML.append("</date_updated></deletedDocument>");

        }

        tablehasrows = rs.next();

      }

      returnXML.append("</updates></replication>");

      conn.close();

      //System.out.println(returnXML.toString());

      out.print(returnXML.toString());

    }

    catch(Exception e)

    {

      System.out.println("Exception in metacatReplication: " + e.getMessage());

    }

  }

  /**

   * Sends the current system date to the remote server.  Using this action

   * for replication gets rid of any problems with syncronizing clocks 

   * because a time specific to a document is always kept on its home server.

   */

  private void handleGetTimeRequest(PrintWriter out, Hashtable params, 

                                    HttpServletResponse response)

  {

    SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

    java.util.Date localtime = new java.util.Date();

    String dateString = formatter.format(localtime);

    response.setContentType("text/xml");

    out.println("<timestamp>" + dateString + "</timestamp>");

  }

  /**

   * This method is what is run when a seperate thread is broken off to handle

   * inserting a document from a remote replicated server.

   */

  public void run()

  {

    try

    {

      System.out.println("thread started for docid: " + 

                         (String)fileLocks.elementAt(0));

      Thread.sleep(30000); //the lock will expire in 30 seconds

      System.out.println("thread for docid: " + 

                         (String)fileLocks.elementAt(fileLocks.size() - 1) + 

                         " exiting.");

      fileLocks.remove(fileLocks.size() - 1);

      //fileLocks is treated as a FIFO queue.  If there are more than one lock

      //in the vector, the first one inserted will be removed.

    }

    catch(Exception e)

    {

      System.out.println("error in file lock thread: " + e.getMessage());

    }

  }

  /**

   * Returns the name of a server given a serverCode

   * @param serverCode the serverid of the server

   * @return the servername or null if the specified serverCode does not

   *         exist.

   */

  public static String getServer(int serverCode)

  {

    try

    {

      Connection conn = util.openDBConnection();

      PreparedStatement pstmt = conn.prepareStatement("select server from " +

                              "xml_replication where serverid = " + 

                              serverCode);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      if(tablehasrows)

      {

        conn.close();

        return rs.getString(1);

      }

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("Error in MetacatReplication.getServer: " + 

                          e.getMessage());

    }

    return null;

      //return null if the server does not exist

  }

}