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

 *     '$Date$'

 * '$Revision$'

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.sql.*;

import java.net.*;

import java.lang.*;

import java.text.*;

import javax.servlet.*;

import javax.servlet.http.*;

  Timer replicationDaemon;

  private Vector fileLocks = new Vector();

  private Thread lockThread = null;

   * Initialize the servlet by creating appropriate database connections

   */

    deltaT = util.getOption("deltaT");

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

       {

          public java.net.URLStreamHandler createURLStreamHandler(

                        final String protocol)

          {

                    URLStreamHandler urlsh = new HTTPClient.http.Handler();

                    MetaCatUtil.debugMessage("Using HttpClient Protocol Handler for http", 45);

                    return urlsh;

                  catch (Exception e)

                     MetaCatUtil.debugMessage(

                          "Error setting URL StreamHandler!", 30);

                     return null;

                  }

               }//if

                   URLStreamHandler urlsh = new HTTPClient.https.Handler();

                   MetaCatUtil.debugMessage("Using HttpClient Protocol Handler for https", 45);

                   return urlsh;

                 catch (Exception e)

                   MetaCatUtil.debugMessage(

                              "Error setting URL StreamHandler!", 30);

                   return null;

                 }

              }

              return null;

         }//createURLStreamHandler

  public void destroy()

    replicationDaemon.cancel();

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  public void doPost(HttpServletRequest request, HttpServletResponse response)

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  private void handleGetOrPost(HttpServletRequest request,

                               HttpServletResponse response)

                               throws ServletException, IOException

    //ServletOutputStream outPut = response.getOutputStream();

// REPLACED with running replication comminications over HTTPS

//    String requestingServerIP = request.getRemoteAddr();

//    InetAddress iaddr = InetAddress.getByName(requestingServerIP);

//    String requestingServer = iaddr.getHostName();

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

    String server = null;

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

           !action.equals("start") &&

           !action.equals("getall") ) {

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

          return;

        } else {

        }

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

                         e.getMessage() );

    }

      handleGetDataFileRequest(out, params, response);

      out.close();

    }

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

      handleForceReplicateDataFileRequest(params);

    {

    PrintWriter out = response.getWriter();

      replicationDaemon.cancel();

      replicationDaemon = new Timer(true);

      out.println("Replication Handler Stopped");

      MetacatReplication.replLog("deltaT handler stopped");

      int rate;

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

        rate = new Integer(

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

        if(rate < 30) {

        }

        rate = 1000;

      }

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

      replicationDaemon.cancel();

      replicationDaemon = new Timer(true);

      out.println("Replication Handler Started");

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

      response.setContentType("text/html");

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

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

      handleForceReplicateDeleteRequest(out, params, response);

      handleUpdateRequest(out, params, response);

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

      //handleGetDocumentAction().

      handleGetDocumentRequest(out, params, response);

      response.setContentType("text/html");

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

  /**

   * xml_replication.

   * action           subaction            other needed params

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

   * servercontrol    add                  server

   * servercontrol    delete               server

  private void handleServerControlRequest(PrintWriter out, Hashtable params,

                                          HttpServletResponse response)

  {

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

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    String server = null;

    String dataReplicate = null;

    String hub = null;

      dbConn=DBConnectionPool.

               getDBConnection("MetacatReplication.handleServerControlRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

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

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

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

        //Get hub value

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

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

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

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

                                      dbAdapter.toDate("01/01/1980", "MM/DD/YYYY")

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

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

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

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

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

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

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

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

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

        }

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

        // and import it as a trusted certificate

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

        downloadCertificate(certURL);

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

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

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

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

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

        //increase dbconnection usage

        dbConn.increaseUsageCount(1);

        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(5) + "</td><td>");

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

        }

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

      // list servers in server list

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

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

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

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

        ResultSet rs = pstmt.getResultSet();

        boolean tablehasrows = rs.next();

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

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

        }

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

      {

    } catch(Exception e) {

                         "MetacatReplication.handleServerControlRequest " +

      e.printStackTrace(System.out);

    }

    {

      try

      {

        pstmt.close();

      }//try

      catch (SQLException ee)

      {

      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

                throws FileNotFoundException, IOException, MalformedURLException

  {

    MetaCatUtil util = new MetaCatUtil();

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

    String filename = certURL;

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

    if ( slash > -1 ) {

      filename = filename.substring(slash + 1);

    }

    File f = new File(certPath, filename);

        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;

      }

      // 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.close();

            fos.close();

  }

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

   * Then store it in local database.

                                           HttpServletResponse response)

  {

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

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

    int serverCode = 1;

    int serialNumber = -1;

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

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

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

      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

                +util.getLocalReplicationServerName()

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

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

      XMLReader docinfoParser = ReplicationHandler.initParser(dih);

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

      Hashtable docinfoHash = dih.getDocInfo();

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

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

      String parserBase = null;

      // this for eml2 and we need user eml2 parser

      {

         MetaCatUtil.debugMessage("This is an eml2.0.1 document!", 30);

         parserBase = DocumentImpl.EML200;

      }

      else if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_1_0NAMESPACE))

      {

         MetaCatUtil.debugMessage("This is an eml2.1.0 document!", 30);

         parserBase = DocumentImpl.EML210;

      }

              getDBConnection("MetacatReplication.handleForceReplicateRequest");

      serialNumber=dbConn.getCheckOutSerialNumber();

                                 "action " + dbaction);

                                      "action " + dbaction + " because "+

                                       e.getMessage());

      MetaCatUtil.debugMessage("ERROR in MetacatReplication.handleForceReplicate" +

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

    {

    }//finally

 * when a forcereplication delete request comes in, local host will delete this

 * document

 */

private void handleForceReplicateDeleteRequest(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

  try

  {

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

    MetacatReplication.replLog("force replication delete docid " + docid);

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

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

    DocumentImpl.delete(docid, null, null, server);

    MetacatReplication.replLog("document " + docid + " was successfully deleted ");

    MetaCatUtil.debugMessage("document " + docid + " was successfully deleted ", 34);

  }

  catch(Exception e)

  {

    MetacatReplication.replErrorLog("document " + docid +

                                    " failed to delete because "+

                                     e.getMessage());

    MetaCatUtil.debugMessage("ERROR in MetacatReplication.handleForceDeleteReplicate" +

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

  }//catch

}

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

   */

  private void handleForceReplicateDataFileRequest(Hashtable params)

  {

    if(params.isEmpty())

    {

      return;

    }

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

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

                              , 20);

    }

    try

      int rev=MetaCatUtil.getVersionFromString(docid);

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