Metacat

        { //the servercheckcode allows this server to check for updated 

          //file from other servers as well as just updated files from 

          //this server.

          handleUpdateRequest2(out, params, response);

    String dbaction = "UPDATE";

    boolean override = false;

    int serverCode = 1;

      if(params.containsKey("dbaction"))

      {

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

        serverCode = MetacatReplication.getServerCode(server);

        override = true;

      }

      System.out.println("action in forcereplicate is: " + dbaction);

      System.out.println("serverCode in forcereplicate is: " + serverCode);

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

                         user, group, serverCode, override);

   * Sends an update list based on rev numbers instead of dates.

   */

  private void handleUpdateRequest2(PrintWriter out, Hashtable params, 

                                    HttpServletResponse response)

  {

    System.out.println("in handleUpdateRequest2");

    try

    {

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

      StringBuffer docsql = new StringBuffer();

      StringBuffer doclist = new StringBuffer();

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

      Connection conn = util.openDBConnection();

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

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tablehasrows = rs.next();

      while(tablehasrows)

      {

        doclist.append("<updatedDocument>");

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

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

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

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

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

        tablehasrows = rs.next();

      }

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

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

      conn.close();

      response.setContentType("text/xml");

      out.println(doclist.toString());

    }

    catch(Exception e)

    {

      System.out.println("error in handleupdaterequest2: " + e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

import java.util.Enumeration;

    return write(conn, xml, null, action, docid, user, group, serverCode); 

  public static String write( Connection conn, Reader xml, Reader acl,

                              String action, String docid, String user,

                              String group, int serverCode) throws Exception

  {

    return write(conn, xml, acl, action, docid, user, group, serverCode, false);

  }

                              String group, int serverCode, boolean override)

                              throws Exception 

                        serverCode + " override: " + override);

    if((serverCode != 1 && action.equals("UPDATE")) && !override)

        if ( action.equals("UPDATE") )  

    //force replicate out the new document to each server in our server list.

    if(serverCode == 1)

    {

      Enumeration keys = (ReplicationHandler.buildServerList(conn)).keys();

      while(keys.hasMoreElements())

      {

        String server = (String)(keys.nextElement());

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

                                   "?action=forcereplicate&server=" + 

                                   util.getOption("server") + 

                                   util.getOption("replicationpath") +

                                   "&docid=" + newdocid + "&dbaction=" +

                                   action);

        System.out.println("sending message: " + comeAndGetIt.toString());

        String message = MetacatReplication.getURLContent(comeAndGetIt);

      }

    }

    if(currentTag.equals("rev") && update)

    {

      indivUpdate.add(new String(ch, start, length));

      indivUpdate.add(server);

    }

    else if(currentTag.equals("rev") && delete)

    {

      indivDelete.add(new String(ch, start, length));

      indivDelete.add(server);

    }

      update2(serverList, conn);

   * Method that uses revision taging for replication instead of update_date.

   */

  private void update2(Hashtable serverList, Connection conn)

  {

    /*

     Pseudo-algorithm

     - request a doc list from each server in xml_replication

     - check the rev number of each of those documents agains the 

       documents in the local database

     - pull any documents that have a lesser rev number on the local server

       from the remote server

     - delete any documents that still exist in the local xml_documents but

       are in the deletedDocuments tag of the remote host response.

     - update last_checked to keep track of the last time it was checked.

       (this info is theoretically not needed using this system but probably 

       should be kept anyway)

    */

    Enumeration keys;

    String server;

    String update;

    ReplMessageHandler message = new ReplMessageHandler();

    Vector responses = new Vector();

    PreparedStatement pstmt;

    ResultSet rs;

    boolean tablehasrows;

    boolean flag=false;

    String action = new String();

    XMLReader parser;

    URL u;

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

    try

    {

      //System.out.println("init parser");

      parser = initParser(message);

      keys = serverList.keys();

      while(keys.hasMoreElements())

      {

        //System.out.println("get responses");

        server = (String)(keys.nextElement());

        u = new URL("http://" + server + "?action=update");

        String result = MetacatReplication.getURLContent(u);

        //System.out.println(result);

        responses.add(result);

      }

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

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

      { //check each server for updated files

        //System.out.println("parsing responses");

        parser.parse(new InputSource(

                     new StringReader(

                     (String)(responses.elementAt(i)))));

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

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

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

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

        //in the local DB.

        for(int j=0; j<v.size(); j++)

        {

          Vector w = new Vector((Vector)(v.elementAt(j)));

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

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

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

          int rev = Integer.parseInt((String)w.elementAt(1));

          //System.out.println("rev: " + rev);

          String docServer = (String)w.elementAt(2);

          //System.out.println("docServer: " + docServer);

          pstmt = conn.prepareStatement("select rev from xml_documents where "+

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

          pstmt.execute();

          rs = pstmt.getResultSet();

          tablehasrows = rs.next();

          if(tablehasrows)

          { //check the revs for an update because this document is in the

            //local DB, it just might be out of date.

            int localrev = rs.getInt(1);

            if(localrev == rev)

            {

              flag = false;

            }

            else if(localrev < rev)

            {//this document needs to be updated so send an read request

              action = "UPDATE";

              flag = true;

            }

          }

          else

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

            action = "INSERT";

            flag = true;

          }

          if(flag)

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

            u = new URL("http://" + docServer + "?action=read&docid=" +

                          docid);

            String newxmldoc = MetacatReplication.getURLContent(u);

            DocInfoHandler dih = new DocInfoHandler();

            XMLReader docinfoParser = initParser(dih);

            URL docinfoUrl = new URL("http://" + docServer + 

                                   "?action=getdocumentinfo&docid=" +

                                   docid);

            String docInfoStr = MetacatReplication.getURLContent(docinfoUrl);

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

            Hashtable docinfoHash = dih.getDocInfo();

            int serverCode = MetacatReplication.getServerCode(docServer);

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

            String newDocid = DocumentImpl.write(conn, 

                              new StringReader(newxmldoc),

                              null,

                              action, 

                              docid, 

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

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

                              serverCode, 

                              true);

          }

        }

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

        { //delete the deleted documents;

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

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

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

          System.out.println("Document " + docid + " deleted.");

        }

        keys = serverList.keys();

        while(keys.hasMoreElements())

        {

          server = (String)(keys.nextElement()); 

          URL dateurl = new URL("http://" + server + "?action=gettime");

          String datexml = MetacatReplication.getURLContent(dateurl);

          String datestr = datexml.substring(11, datexml.indexOf('<', 11));

          StringBuffer sql = new StringBuffer();

          sql.append("update xml_replication set last_checked = to_date('");

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

          sql.append("server like '").append(server).append("'");

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

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

          pstmt.executeUpdate();

          //conn.commit();

          System.out.println("last_checked updated to " + datestr + " on " +

                            server);

        }

      }

    }

    catch(Exception e)

    {

      System.out.println("error in update2: " + e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**

  public static Hashtable buildServerList(Connection conn)