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

 *     '$Date: 2002-07-14 12:33:25 -0700 (Sun, 14 Jul 2002) $'

 * '$Revision: 1292 $'

 *

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

    //ServletOutputStream outPut = response.getOutputStream();

    Hashtable params = new Hashtable();

    Enumeration paramlist = request.getParameterNames();

// NOT NEEDED - doesn't provide enough security because of possible IP spoofing

// REPLACED with running replication comminications over HTTPS

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

    }

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

    String server = null;

    try {

      // check if the server is included in the list of replicated servers

      if ( !action.equals("servercontrol") && 

           !action.equals("stop") &&

           !action.equals("start") &&

           !action.equals("getall") ) {

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

        if ( getServerCodeForServerName(server) == 0 ) {

          System.out.println("Action \"" + action + 

                             "\" rejected for server: " + server);

          return;

        } else {

          System.out.println("Action \"" + action + 

                             "\" accepted for server: " + server);

        }

      }

    } catch (Exception e) {

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

                         e.getMessage() );

      return;

    }

    if ( action.equals("readdata") ) 

    {

      OutputStream out=response.getOutputStream();

      //to get the data file.

      handleGetDataFileRequest(out, params, response);

      out.close();

    }

    else if ( action.equals("forcereplicatedatafile") ) 

    {

      //read a specific docid from remote host, and store it into local host

      handleForceReplicateDataFileRequest(params);

    }

    else

    {

    PrintWriter out = response.getWriter();

    if ( action.equals("stop") ) {

      //stop the replication server

      replicationDaemon.cancel();

      replicationDaemon = new Timer(true);

      out.println("Replication Handler Stopped");

      MetacatReplication.replLog("deltaT handler stopped");

    } else if ( action.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);

      out.println("Replication Handler Started");

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

                                    rate + " seconds");

    } else if ( action.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 ( action.equals("forcereplicate") ) {

      //read a specific docid from remote host, and store it into local host

      handleForceReplicateRequest(out, params, response);

    } else if ( action.equals("update") ) {

      //request an update list from the server

      handleUpdateRequest(out, params, response);

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

      handleGetLockRequest(out, params, response);

    } else if ( action.equals("getdocumentinfo") ) {

      handleGetDocumentInfoRequest(out, params, response);

    } else if ( action.equals("gettime") ) {

      handleGetTimeRequest(out, params, response);

    } else if ( action.equals("getcatalog") ) {

      handleGetCatalogRequest(out, params, response, true);

    } else if ( action.equals("servercontrol") ) {

      handleServerControlRequest(out, params, response);

    } else if ( action.equals("test") ) {

      response.setContentType("text/html");

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

    }

    out.close();

    }//else

  }

  /** 

   * 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];

    DBConnection dbConn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    String replicate =null;

    String server = null;

    String dataReplicate = null;

    String hub = null;

    try {

      //conn = util.openDBConnection();

      dbConn=DBConnectionPool.

               getDBConnection("MetacatReplication.handleServerControlRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // add server to server list

      if ( subaction.equals("add") ) {

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

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

        //Get data replication value

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

        //Get hub value

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

        pstmt = dbConn.prepareStatement("INSERT INTO xml_replication " +

                  "(server, last_checked, replicate, datareplicate, hub) " +

                                      "VALUES ('" + server + "', to_date(" +

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

                                      replicate +"', '" +dataReplicate+"', '"

                                      + hub +"')");

        pstmt.execute();

        pstmt.close();

        dbConn.commit();

        out.println("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>");

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

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

        pstmt = dbConn.prepareStatement("SELECT * FROM xml_replication");

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

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

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

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

          tablehasrows = rs.next();

        }

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

        // download certificate with the public key on this server

        // and import it as a trusted certificate

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

        downloadCertificate(certURL);

      // delete server from server list

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

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

        pstmt = dbConn.prepareStatement("DELETE FROM xml_replication " +

                                      "WHERE server LIKE '" + server + "'");

        pstmt.execute();

        pstmt.close();

        dbConn.commit();

        out.println("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>");

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

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

        pstmt = dbConn.prepareStatement("SELECT * FROM xml_replication");

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

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

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

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

          tablehasrows = rs.next();

        }

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

      // list servers in server list

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

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

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

        pstmt = dbConn.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><td>");

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

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

          tablehasrows = rs.next();

        }

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

      } 

      else

      {

        out.println("<error>Unkonwn subaction</error>");

      }

      pstmt.close();

      //conn.close();

    } catch(Exception e) {

      System.out.println("Error in " + 

                         "MetacatReplication.handleServerControlRequest " + 

                         e.getMessage());

      e.printStackTrace(System.out);

    }

    finally

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException ee)

      {

        MetaCatUtil.debugMessage("Error in " + 

                "MetacatReplication.handleServerControlRequest to close pstmt "

                 + ee.getMessage());

      }//catch

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

      }//finally

    }//finally

  }

  // download certificate with the public key from certURL and 

  // upload it onto this server; it then must be imported as a 

  // trusted certificate 

  private void downloadCertificate (String certURL)

                throws FileNotFoundException, IOException, MalformedURLException

  {

    MetaCatUtil util = new MetaCatUtil();

    String certPath = util.getOption("certPath"); //the path to be uploaded to

    // get filename from the URL of the certificate

    String filename = certURL;

    int slash = Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'));

    if ( slash > -1 ) {

      filename = filename.substring(slash + 1);

    }

    // open file output strem to write the input into it

    File f = new File(certPath, filename);

    synchronized (f) { 

      try {

        if ( f.exists() ) {

          throw new IOException("File already exist: " + f.getCanonicalFile());

          //if ( f.exists() && !f.canWrite() ) {

          //  throw new IOException("Not writable: " + f.getCanonicalFile());

        }

      } catch (SecurityException se) {

        // if a security manager exists,

        // its checkRead method is called for f.exist()

        // or checkWrite method is called for f.canWrite()

        throw se;

      }

      // create a buffered byte output stream

      // that uses a default-sized output buffer

      FileOutputStream fos = new FileOutputStream(f);

      BufferedOutputStream out = new BufferedOutputStream(fos);

      // this should be http url

      URL url = new URL(certURL);

      BufferedInputStream bis = null;

      try {

        bis = new BufferedInputStream(url.openStream());

        byte[] buf = new byte[4 * 1024]; // 4K buffer

        int b = bis.read(buf);

        while (b != -1) {

          out.write(buf, 0, b);

          b = bis.read(buf);

        }

      } finally {

        if (bis != null) bis.close();

      }

      // the input and the output streams must be closed

      bis.close();

	    out.flush();

	    out.close();

	    fos.close();

    } // end of synchronized(f)

  }

  /**

   * when a forcereplication request comes in, local host sends a read request

   * to the requesting server (remote server) for the specified docid.

   * Then store it in local database.

   */

  private void handleForceReplicateRequest(PrintWriter out, Hashtable params,

                                           HttpServletResponse response)

  {

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

    String docid = ((String[])params.get("docid"))[0]; // sent the document

    String dbaction = "UPDATE"; // the default action is UPDATE

    boolean override = false;

    int serverCode = 1;

    DBConnection dbConn = null;

    int serialNumber = -1;

    try {

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

      if(params.containsKey("dbaction")) {

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

        //serverCode = MetacatReplication.getServerCode(server);

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

      }

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

      MetaCatUtil.debugMessage("Force replication request from: "+ server, 34);

      MetaCatUtil.debugMessage("Force replication docid: "+docid, 34);

      MetaCatUtil.debugMessage("Force replication action: "+dbaction, 34);

      // sending back read request to remote server

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

                +util.getLocalReplicationServerName()

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

      String xmldoc = MetacatReplication.getURLContent(u);

      // get the document info from server

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

                               "?server="+util.getLocalReplicationServerName()

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

      String docInfoStr = MetacatReplication.getURLContent(docinfourl);

      //dih is the parser for the docinfo xml format

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = ReplicationHandler.initParser(dih);

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

      Hashtable docinfoHash = dih.getDocInfo();

      // Get user owner of this docid

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

      // Get home server of this docid

      String homeServer=(String)docinfoHash.get("home_server");

      MetaCatUtil.debugMessage("homeServer: "+homeServer, 34);

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

              getDBConnection("MetacatReplication.handleForceReplicateRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

      // write the document to local database

      DocumentImpl.writeReplication(dbConn, 

                  new StringReader(xmldoc), null, null, dbaction, docid, user, 

                  null, homeServer, false, server);

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

                                 "action " + dbaction);

    }//try

    catch(Exception e) 

    {

      System.out.println("ERROR in MetacatReplication.handleForceReplicate" +

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

       e.printStackTrace();

    }//catch

    finally

    {

      // Return the checked out DBConnection

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

  }

  /**

   * when a forcereplication data file request comes in, local host sends a 

   * readdata request to the requesting server (remote server) for the specified 

   * docid. Then store it in local database and file system

   */

  private void handleForceReplicateDataFileRequest(Hashtable params)

  {

    //make sure there is some parameters

    if(params.isEmpty())

    {

      return;

    }

    // Get remote server 

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

    // the docid should include rev number

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

    // Make sure there is a docid and server

    if (docid==null || server==null || server.equals(""))

    {

      MetaCatUtil.debugMessage("Didn't specify docid or server for replication"

                              , 20);

      return;

    }

    // Overide or not

    boolean override = false;

    // dbaction - update or insert

    String dbaction=null;

    try 

    {

      //docid was switch to two parts uinque code and rev

      String uniqueCode=MetaCatUtil.getDocIdFromString(docid);

      int rev=MetaCatUtil.getVersionFromString(docid);

      if(params.containsKey("dbaction")) 

      {

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

      }

      else//default value is update

      {

        dbaction = "update";

      }

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

      MetaCatUtil.debugMessage("Force replication request from: "+ server, 34);

      MetaCatUtil.debugMessage("Force replication docid: "+docid, 34);

      MetaCatUtil.debugMessage("Force replication action: "+dbaction, 34);

      // get the document info from server

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

                               "?server="+util.getLocalReplicationServerName()

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

      String docInfoStr = MetacatReplication.getURLContent(docinfourl);

      //dih is the parser for the docinfo xml format

      DocInfoHandler dih = new DocInfoHandler();

      XMLReader docinfoParser = ReplicationHandler.initParser(dih);

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

      String docHomeServer= (String)docinfoHash.get("home_server");

      MetaCatUtil.debugMessage("docHomeServer of datafile: "+docHomeServer, 34);

      //if action is delete, we don't delete the data file. Just archieve

      //the xml_documents

      if (dbaction.equals("delete"))

      {

        //conn = util.getConnection();

        DocumentImpl.delete(docid,user,null);

        //util.returnConnection(conn);

      }

      //To data file insert or update is same

      else if (dbaction.equals("insert")||dbaction.equals("update"))

      {

        //Get data file and store it into local file system.

        // sending back readdata request to server

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

                +util.getLocalReplicationServerName()

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

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

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

        //into file system

        DocumentImpl.writeDataFileInReplication(url.openStream(), datafilePath, 

                            docName, docType, docid, user,docHomeServer,server);

     }

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

                                 "action " + dbaction);

    } catch(Exception e) 

    {

      //util.returnConnection(conn);

      util.debugMessage

              ("ERROR in MetacatReplication.handleForceDataFileReplicate" +

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

    }

  }

  /**

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

  {

    try

    {

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

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

      DocumentImpl requestDoc = new DocumentImpl(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();

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

    try

    {

      DocumentImpl doc = new DocumentImpl(docid);

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

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

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

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

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

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

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

      sb.append("<home_server>");

      sb.append(doc.getDocHomeServer());

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

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

    }

    catch (Exception e)

    {

      System.out.println("error in " +

                         "metacatReplication.handlegetdocumentinforequest: " + 

                          e.getMessage());

    }

  }

  /**

   * Sends a datafile to a remote host

   */

  private void handleGetDataFileRequest(OutputStream outPut, 

                            Hashtable params, HttpServletResponse response)

  {

    // File path for data file    

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

    // Request docid

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

    //check if the doicd is null

    if (docId==null)

    {

      util.debugMessage("Didn't specify docid for replication", 20);

      return;

    }

    //try to open a https stream to test if the request server's public key

    //in the key store, this is security issue

    try

    {

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

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

                +util.getLocalReplicationServerName()

                +"&action=test");

      String test = MetacatReplication.getURLContent(u);

      //couldn't pass the test

      if (test.indexOf("successfully")==-1)

      {

        //response.setContentType("text/xml");

        //outPut.println("<error>Couldn't pass the trust test</error>");

        MetaCatUtil.debugMessage("Couldn't pass the trust test", 20);

        return;

      }

    }//try

    catch (Exception ee)

    {

      return;

    }//catch

    if(!filepath.endsWith("/")) 

    {

          filepath += "/";

    }

    // Get file aboslute file name

    String filename = filepath + docId;      

    //MIME type

    String contentType = null;

    if (filename.endsWith(".xml")) 

    {

        contentType="text/xml";

    } 

    else if (filename.endsWith(".css")) 

    {

        contentType="text/css";

    } 

    else if (filename.endsWith(".dtd")) 

    {

        contentType="text/plain";

    } 

    else if (filename.endsWith(".xsd")) 

    {

        contentType="text/xml";

    } 

    else if (filename.endsWith("/")) 

    {

        contentType="text/html";

    } 

    else 

    {

        File f = new File(filename);

        if ( f.isDirectory() ) 

        {

           contentType="text/html";

        } 

        else

        {

           contentType="application/octet-stream";

        }

     }

   // Set the mime type

   response.setContentType(contentType);

   // Get the content of the file

   FileInputStream fin = null;

   try 

   {

      // FileInputStream to metacat

      fin = new FileInputStream(filename);

      // 4K buffer

      byte[] buf = new byte[4 * 1024];

      // Read data from file input stream to byte array

      int b = fin.read(buf);

      // Write to outStream from byte array

      while (b != -1) 

      {

        outPut.write(buf, 0, b);

        b = fin.read(buf);

      }

      // close file input stream

      fin.close();

   }//try

   catch(Exception e)

   {

      System.out.println("error getting data file from MetacatReplication." +

                         "handlGetDataFileRequest " + e.getMessage());

      e.printStackTrace(System.out);

   }//catch

}

  /**

   * Sends a document to a remote host

   */

  private void handleGetDocumentRequest(PrintWriter out, Hashtable params, 

                                        HttpServletResponse response)

  {

    try

    {

      //try to open a https stream to test if the request server's public key

      //in the key store, this is security issue

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