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: 2001-03-14 12:46:09 -0800 (Wed, 14 Mar 2001) $'

 * '$Revision: 727 $'

 *

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

import java.io.*;

import java.sql.*;

import java.net.*;

import java.lang.*;

import java.text.*;

import javax.servlet.*;

import javax.servlet.http.*;

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

    //the default deltaT can be set from metacat.properties

    //create a thread to do the delta-T check but don't execute it yet

    replicationDaemon = new Timer(true);

  }

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

    String servletAction = null;

    String requestingServerIP = request.getRemoteAddr();

    InetAddress iaddr = InetAddress.getByName(requestingServerIP);

    String requestingServer = iaddr.getHostName();

    while (paramlist.hasMoreElements()) 

    {

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

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

      params.put(name, value);  

    }

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

    //if the requesting Server is not in the server list

    //reject this request

    //this does not protect against IP spoofing but it does

    //protect against simple URL parameter spoofing.

    //We need to add an authenticated  "replication" user who can perform the 

    //actions listed below in the !servletAction.equals calls.  

    try

    {

      if(getServerCode(requestingServer + "%") == 0 &&

         !servletAction.equals("servercontrol") && 

         !servletAction.equals("stop") &&

         !servletAction.equals("start") &&

         !servletAction.equals("getall"))

      {

        System.out.println("action rejected for server: " + requestingServer);

        return;

      }

      System.out.println("action accepted for server: " + requestingServer);

    }

    catch(Exception e)

    {

      System.out.println("error in MetacatReplication.handleGetOrPost" +

      ": error authenticating server");

      return;

    }

    if(params.containsKey("action"))

    {

      if(servletAction.equals("stop"))

      { //stop the replication server

        replicationDaemon.cancel();

        replicationDaemon = new Timer(true);

        out.println("Replication Handler Stopped");

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

        MetacatReplication.replLog("deltaT handler stopped");

      }

      else if(servletAction.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!");

            //deltaT<30 is a timing mess!

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

        MetacatReplication.replLog("deltaT handler started with rate=" + 

                                    rate + " seconds");

        out.println("Replication Handler Started");

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

      }

      else if(servletAction.equals("getall"))

      { //updates this server exactly once

        replicationDaemon.schedule(new ReplicationHandler(out), 0);

        response.setContentType("text/html");

        out.println("<html><body>\"Get All\" Done</body></html>");

      }

      else if(servletAction.equals("forcereplicate"))

      {

        handleForceReplicateRequest(out, params, response);

      }

      else if(servletAction.equals("update"))

      { //request an update list from the server

        handleUpdateRequest(out, params, response);

      }

      else if(servletAction.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(servletAction.equals("getlock"))

      {

        handleGetLockRequest(out, params, response);

      }

      else if(servletAction.equals("getdocumentinfo"))

      {

        handleGetDocumentInfoRequest(out, params, response);

      }

      else if(servletAction.equals("gettime"))

      {

        handleGetTimeRequest(out, params, response);

      }

      else if(servletAction.equals("getcatalog"))

      {

        handleGetCatalogRequest(out, params, response, true);

      }

      else if(servletAction.equals("servercontrol"))

      {

        handleServerControlRequest(out, params, response);

      }

    }

  }

  /** 

   * This method can add, delete and list the servers currently included in

   * xml_replication.

   * action           subaction            other needed params

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

   * servercontrol    add                  server

   * servercontrol    delete               server

   * servercontrol    list                 

   */

  private void handleServerControlRequest(PrintWriter out, Hashtable params,

                                          HttpServletResponse response)

  {

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

    Connection conn = null;

    try

    {

      conn = MetacatReplication.getDBConnection("MetacatReplication." + 

                                                "handleServerControlRequest");

      PreparedStatement pstmt = null;

      if(subaction.equals("add"))

      {

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

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

        pstmt = conn.prepareStatement("insert into xml_replication (server, " +

                "last_checked, replicate) values ('" + server + "', to_date(" +

                "'01/01/00', 'MM/DD/YY'), '" + replicate + "')");

        pstmt.execute();

        out.println("Server says: server " + server + " added"); 

        response.setContentType("text/html");

        out.println("<html><body><table border=\"1\">");

        out.println("<tr><td><b>server</b></td><td><b>last_checked</b></td><td>");

        out.println("<b>replicate</b></td></tr>");

        pstmt = conn.prepareStatement("select * from xml_replication");

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

        while(tablehasrows)

        {

          out.println("<tr><td>" + rs.getString(2) + "</td><td>");

          out.println(rs.getString(3) + "</td><td>");

          out.println(rs.getString(4) + "</td></tr>");

          tablehasrows = rs.next();

        }

        out.println("</table></body></html>");

      }

      else if(subaction.equals("delete"))

      {

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

        pstmt = conn.prepareStatement("delete from xml_replication where " +

                "server like '" + server + "'");

        pstmt.execute();

        out.println("Server says: server " + server + " deleted");

        response.setContentType("text/html");

        out.println("<html><body><table border=\"1\">");

        out.println("<tr><td><b>server</b></td><td><b>last_checked</b></td><td>");

        out.println("<b>replicate</b></td></tr>");

        pstmt = conn.prepareStatement("select * from xml_replication");

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

        while(tablehasrows)

        {

          out.println("<tr><td>" + rs.getString(2) + "</td><td>");

          out.println(rs.getString(3) + "</td><td>");

          out.println(rs.getString(4) + "</td></tr>");

          tablehasrows = rs.next();

        }

        out.println("</table></body></html>");

      }

      else if(subaction.equals("list"))

      {

        response.setContentType("text/html");

        out.println("<html><body><table border=\"1\">");

        out.println("<tr><td><b>server</b></td><td><b>last_checked</b></td><td>");

        out.println("<b>replicate</b></td></tr>");

        pstmt = conn.prepareStatement("select * from xml_replication");

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

        while(tablehasrows)

        {

          out.println("<tr><td>" + rs.getString(2) + "</td><td>");

          out.println(rs.getString(3) + "</td><td>");

          out.println(rs.getString(4) + "</td></tr>");

          tablehasrows = rs.next();

        }

        out.println("</table></body></html>");

      }

      pstmt.close();

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("error in " + 

                         "MetacatReplication.handleServerControlRequest " + 

                         e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

   * when a forcereplication request comes in, this method sends a read request

   * to the requesting server for the specified docid.

   */

  private void handleForceReplicateRequest(PrintWriter out, Hashtable params,

                                           HttpServletResponse response)

  {

    //System.out.println("in handleforcereplicaterequest");

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

    if(!(replToServer(server)))

    { //do not get the server's new document if we are not replicating from there

      return;

    }

    //the server that the request came from

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

    //the docid of the document to get

    String dbaction = "UPDATE";

    //default action is update

    boolean override = false;

    int serverCode = 1;

    try

    {

      if(params.containsKey("dbaction"))

      { //if the url contains a dbaction then the default action is overridden

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

        serverCode = MetacatReplication.getServerCode(server);

        override = true; //we are now overriding the default action

      }

      MetaCatUtil.debugMessage("action in forcereplicate is: " + dbaction);

      MetaCatUtil.debugMessage("serverCode in forcereplicate is: " + serverCode);

      MetacatReplication.replLog("force replication request from " + server); 

      int serverCheckCode = MetacatReplication.getServerCode(server);

      URL u = new URL("http://" + server + "?action=read&docid=" + docid);

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

      String xmldoc = MetacatReplication.getURLContent(u);

      MetaCatUtil.debugMessage("document: " + xmldoc);

      //get the document to write

      URL docinfourl = new URL("http://" + server + 

                               "?action=getdocumentinfo&docid=" +

                               docid);

      //we need to get the document's info so we can set the correct user

      //and group once we get the document and write it to our DB

      MetaCatUtil.debugMessage("sending message: " + docinfourl.toString());

      String docInfoStr = MetacatReplication.getURLContent(docinfourl);

      MetaCatUtil.debugMessage("docInfo: " + docInfoStr);

      DocInfoHandler dih = new DocInfoHandler();

      //dih is the parser for the docinfo xml format

      XMLReader docinfoParser = ReplicationHandler.initParser(dih);

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

      Hashtable docinfoHash = dih.getDocInfo();

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

      String group = new String(user);

      //right now the user and group are the same.

      Connection conn = null;

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleForceReplicateRequest");

      DocumentImpl.write(conn, new StringReader(xmldoc), null, dbaction, docid, 

                         user, group, serverCode, override);

      MetacatReplication.replLog("document " + docid + " added to DB with " +

                                 "action " + dbaction);

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("error in metacatReplication.handleForceReplicate" +

                         "Request: " + e.getMessage());

    }

  }

  /**

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

  {

    Connection conn = null;

    try

    {

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleGetLockRequest");

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

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

      DocumentImpl requestDoc = new DocumentImpl(conn, docid);

      MetacatReplication.replLog("lock request for " + docid);

      int localRevInt = requestDoc.getRev();

      int remoteRevInt = Integer.parseInt(remoteRev);

      if(remoteRevInt >= localRevInt)

      {

        if(!fileLocks.contains(docid))

        { //grant the lock if it is not already locked

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

          System.out.println("lock granted for " + docid);

          MetacatReplication.replLog("lock granted for " + docid);

        }

        else

        { //deny the lock

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

          MetacatReplication.replLog("lock denied for " + docid + 

                                     "reason: file already locked");

        }

      }

      else

      {//deny the lock.

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

        MetacatReplication.replLog("lock denied for " + docid + 

                                   "reason: client has outdated file");

      }

      conn.close();

    }

    catch(Exception e)

    {

      System.out.println("error requesting file lock from MetacatReplication." +

                         "handleGetLockRequest: " + e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

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

   * the format is:

   * <!ELEMENT documentinfo (docid, docname, doctype, doctitle, user_owner,

   *                         user_updated, public_access, rev)

   * all of the subelements of document info are #PCDATA

   */

  private void handleGetDocumentInfoRequest(PrintWriter out, Hashtable params, 

                                        HttpServletResponse response)

  {

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

    StringBuffer sb = new StringBuffer();

    Connection conn = null;

    try

    {

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleGetDocumentInfoRequest");

      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 attr cleared from the db

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

      sb.append("<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><rev>").append(doc.getRev());

      sb.append("</rev></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)

  {

    Connection conn = null;

    try

    {

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

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

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleGetDocumentRequest");

      DocumentImpl di = new DocumentImpl(conn, docid);

      response.setContentType("text/xml");

      out.print(di.toString());

      conn.close();

      MetacatReplication.replLog("document " + docid + " sent");

      System.out.println("document " + docid + " sent");

    }

    catch(Exception e)

    {

      System.out.println("error getting document from MetacatReplication." +

                         "handlGetDocumentRequest " + e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

   * Sends a list of all of the documents on this sever along with their

   * revision numbers.  

   * The format is:

   * <!ELEMENT replication (server, updates)>

   * <!ELEMENT server (#PCDATA)>

   * <!ELEMENT updates ((updatedDocument | deleteDocument)*)>

   * <!ELEMENT updatedDocument (docid, rev)>

   * <!ELEMENT deletedDocument (docid, rev)>

   * <!ELEMENT docid (#PCDATA)>

   * <!ELEMENT rev (#PCDATA)>

   * note that the rev in deletedDocument is always empty.  I just left

   * it in there to make the parser implementation easier.

   */

  private void handleUpdateRequest(PrintWriter out, Hashtable params, 

                                    HttpServletResponse response)

  {

    Connection conn = null;

    try

    {

      System.out.println("received update request");

      StringBuffer docsql = new StringBuffer();

      StringBuffer doclist = new StringBuffer();

      Vector packageFiles = new Vector();

      //get all docs that reside on this server

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

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

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

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

      docsql.append("select docid, rev, doctype from xml_documents where "); 

      docsql.append("server_location = 1");

      //get any deleted documents

      StringBuffer delsql = new StringBuffer();

      delsql.append("select distinct docid from ");

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

      delsql.append("xml_documents) and server_location = 1");

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleUpdateRequest");

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

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      while(tablehasrows)

      {

        String recordDoctype = rs.getString(3);

        if(!recordDoctype.equals("BIN"))

        { //don't replicate data files

          if(!recordDoctype.equals(util.getOption("packagedoctype")))

          { //if this is a package file, put it at the end

            //because if a package file is read before all of the files it

            //refers to are loaded then there is an error

            doclist.append("<updatedDocument>");

            doclist.append("<docid>").append(rs.getString(1));

            doclist.append("</docid><rev>").append(rs.getInt(2));

            doclist.append("</rev>");

            doclist.append("</updatedDocument>");

          }

          else

          { //the package files are saved to be put into the xml later.

            Vector v = new Vector();

            v.add(new String(rs.getString(1)));

            v.add(new Integer(rs.getInt(2)));

            packageFiles.add(new Vector(v));

          }

        }

        tablehasrows = rs.next();

      }

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

      pstmt.execute();

      rs = pstmt.getResultSet();

      tablehasrows = rs.next();

      while(tablehasrows)

      { //handle the deleted documents

        doclist.append("<deletedDocument><docid>").append(rs.getString(1));

        doclist.append("</docid><rev></rev></deletedDocument>");

        //note that rev is always empty for deleted docs

        tablehasrows = rs.next();

      }

      //now we can put the package files into the xml results

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

      {

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

        doclist.append("<updatedDocument>");

        doclist.append("<docid>").append((String)v.elementAt(0));

        doclist.append("</docid><rev>");

        doclist.append(((Integer)v.elementAt(1)).intValue());

        doclist.append("</rev>");

        doclist.append("</updatedDocument>");

      }

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

      MetaCatUtil.debugMessage("doclist: " + doclist.toString());

      pstmt.close();

      conn.close();

      response.setContentType("text/xml");

      out.println(doclist.toString());

      System.out.println("doclist: " + doclist.toString());

      System.out.println("update request handled");

    }

    catch(Exception e)

    {

      System.out.println("error in MetacatReplication.handleupdaterequest: " + 

                          e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

   * Returns the xml_catalog table encoded in xml

   */

  public static String getCatalogXML()

  {

    return handleGetCatalogRequest(null, null, null, false);

  }

  /**

   * Sends the contents of the xml_catalog table encoded in xml

   * The xml format is:

   * <!ELEMENT xml_catalog (row*)>

   * <!ELEMENT row (entry_type, source_doctype, target_doctype, public_id,

   *                system_id)>

   * All of the sub elements of row are #PCDATA

   * If printFlag == false then do not print to out.

   */

  private static String handleGetCatalogRequest(PrintWriter out, 

                                                Hashtable params,

                                                HttpServletResponse response,

                                                boolean printFlag)

  {

    Connection conn = null;

    PreparedStatement pstmt = null;

    try

    { 

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "handleGetCatalogRequest");

      pstmt = conn.prepareStatement("select entry_type, " +

                              "source_doctype, target_doctype, public_id, " +

                              "system_id from xml_catalog");

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      StringBuffer sb = new StringBuffer();

      sb.append("<?xml version=\"1.0\"?><xml_catalog>");

      while(tablehasrows)

      {

        sb.append("<row><entry_type>").append(rs.getString(1));

        sb.append("</entry_type><source_doctype>").append(rs.getString(2));

        sb.append("</source_doctype><target_doctype>").append(rs.getString(3));

        sb.append("</target_doctype><public_id>").append(rs.getString(4));

        sb.append("</public_id><system_id>").append(rs.getString(5));

        sb.append("</system_id></row>");

        tablehasrows = rs.next();

      }

      sb.append("</xml_catalog>");

      conn.close();

      if(printFlag)

      {

        response.setContentType("text/xml");

        out.println(sb.toString());

      }

      pstmt.close();

      return sb.toString();

    }

    catch(Exception e)

    {

      try

      {

        pstmt.close();

        conn.close();

      }

      catch(Exception ee)

      {}

      System.out.println("error in MetacatReplication.handleGetCatalogRequest:"+ 

                          e.getMessage());

      e.printStackTrace(System.out);

    }

    return null;

  }

  /**

   * 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 handles the timeout for a file lock.  when a lock is 

   * granted it is granted for 30 seconds.  When this thread runs out

   * it deletes the docid from the queue, thus eliminating the lock.

   */

  public void run()

  {

    try

    {

      MetaCatUtil.debugMessage("thread started for docid: " + 

                               (String)fileLocks.elementAt(0));

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

                               (String)fileLocks.elementAt(0));

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

      MetaCatUtil.debugMessage("thread for docid: " + 

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

                              " exiting.");

      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 from MetacatReplication." + 

                         "run: " + 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)

  {

    //System.out.println("serverid: " + serverCode);

    Connection conn = null;

    try

    {

      conn = MetacatReplication.getDBConnection("MetacatReplication." +

                                                "getServer");

      String sql = new String("select server from " +

                              "xml_replication where serverid = " + 

                              serverCode);

      PreparedStatement pstmt = conn.prepareStatement(sql);

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

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      if(tablehasrows)

      {

        //System.out.println("server: " + rs.getString(1));

        return rs.getString(1);

      }

      pstmt.close();

      conn.close();

    }

    catch(Exception e)

    {

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

                          e.getMessage());

    }

    return null;

      //return null if the server does not exist

  }

  /**

   * Returns a server code given a server name

   * @param server the name of the server

   * @return integer > 0 representing the code of the server, 0 if the server

   *  does not exist.

   */

  public static int getServerCode(String server) throws Exception

  {

    Connection conn = null;

    PreparedStatement pstmt = null;

    try

    {

      conn = MetacatReplication.getDBConnection("MetacatReplication.getServerCode");

      pstmt = conn.prepareStatement("select serverid from " +

                                         "xml_replication where server " +

                                         "like '" + server + "'");

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      int serverCode = 0;

      if(tablehasrows)

      {  

        int ret = rs.getInt(1);

        pstmt.close();

        conn.close();

        return ret;

      }

      else

      {

        pstmt.close();

        conn.close();

        return 0;

      }

    }

    catch(Exception e)

    {

      throw e;

    }

    finally

    {

       try

       {

         pstmt.close();

         conn.close();

       }

       catch(Exception ee) {}

    }

  }

  /**

   * This method returns the content of a url

   * @param u the url to return the content from

   * @return a string representing the content of the url

   * @throws java.io.IOException

   */

  public static String getURLContent(URL u) throws java.io.IOException

  {

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

    char istreamChar;

    int istreamInt;