Metacat

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

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

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

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

    //                   + " seconds");

        if(params.contains("servercheckcode"))

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

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

          //this server.

          System.out.println("metacatreplication: servercheckcode: " + 

                               ((int[])params.get("servercheckcode"))[0]);

          handleUpdateRequest(out, params, response, 

                              ((int[])params.get("servercheckcode"))[0]);

        }

        else

        {

          handleUpdateRequest2(out, params, response);

        }

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

      {

        override = true;

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

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

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

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

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

   * Does default handling for update requests

                                   HttpServletResponse response)

  {

    handleUpdateRequest(out, params, response, 1);

  }

  /**

   * Initiates an update of all server in the xml_replication table.

   * the remote host sends an update date.  The local host (this method)

   * queries the db for any document that was updated after the update date

   * and returns a list of those documents to the remote host.  It also 

   * sends back a list of the files that were locally deleted.

   * serverCheckCode allows the requestor to request documents from this 

   * server that reside on a different server.  Normally, this server

   * should only replicate files that it owns but in the case of updating 

   * a file that does not belong to this server, it is needed.  See 

   * DocumentImpl.write().

   */

  private void handleUpdateRequest(PrintWriter out, Hashtable params, 

                                   HttpServletResponse response, 

                                   int serverCheckCode)

  { 

    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 == serverCheckCode)

        { //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 an update list based on rev numbers instead of dates.

   */

  private void handleUpdateRequest2(PrintWriter out, Hashtable params, 

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

   * inserting a document from a remote replicated server.

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

                         (String)fileLocks.elementAt(0));

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

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

                         " exiting.");

      update2(serverList, conn);

  private void update2(Hashtable serverList, Connection conn)

   * Method to check each server in the servetList for updates

   */

  private void update(Hashtable serverList, Connection conn)

  {

    /*

     Pseudo-algorithm:

     -build a list of servers that need to be checked

     -check each server to see if any documents were modified after the 

      server's update_date

     -if there are documents that need to be updated pull them here

      and update the one currently in the database or add a new one

      if it is not already here.

     -update each servers' update_date to the current time

    */

    PreparedStatement pstmt;

    Enumeration keys;

    int istreamInt;

    char istreamChar;

    StringBuffer serverResponse = new StringBuffer();

    String server;

    String update;

    Vector responses = new Vector();

    ReplMessageHandler message = new ReplMessageHandler();

    Hashtable updateDocs = new Hashtable();

    URL u;

    InputStreamReader istream;

    try

    {

      //build a list of servers with updated documents.  Choose the newest

      //one out of the list, update this server, update last_checked

      keys = serverList.keys();

      while(keys.hasMoreElements())

      { //update from one server at a time

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

        update = (String)(serverList.get(server));

        //send the server a date and it will send back any docid that has 

        //been modified after that date

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

        if(serverCheckCode != 1)

        {

          u = new URL("http://" + server + "?action=update&date=" + update +

                      "&servercheckcode=" + serverCheckCode);

        }

        else

        {

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

        }

        responses.add(MetacatReplication.getURLContent(u)); //list of updates

      }

      //initialize the parser

      XMLReader parser = initParser(message);

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

      //System.out.println("<--end response-->");

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

      { //parse the xml and get the result

        parser.parse(new InputSource(

                     new StringReader(

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

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

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

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

        { //go through each update vector and update or insert

          //a new document

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

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

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

          //send a message to the server requesting each document

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

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

          String srvrResponseStr = MetacatReplication.getURLContent(getDocURL);

          //System.out.println("<<<<<<document>>>>>");

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

          //System.out.println("<<<<<<end document>>>>>");

          int serverCode = MetacatReplication.getServerCode(docServer);

          if(serverCode != 0)

          {

            //update the document into the DB

            String action = getAction(docid);

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

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

            String newDocid = DocumentImpl.write(conn, 

                               new StringReader(srvrResponseStr),

                               action, 

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

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

                               serverCode);

            System.out.println("newDocid: " + newDocid + " " + action + "ED");

          }

        }

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

        {

          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 = null;

      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 replicationHandler.update(): " + 

                         e.getMessage());

      e.printStackTrace(System.out);

    }

  }

  /**