/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 5014

Added by daigle over 15 years ago

Create replication directory. Move replication code there. Use log4j for replication logging (rollingfileappender). Beef up replication logging and error control.

     /**
      *  '$RCSfile$'
      *    Purpose: A class represent a server in xml_replcation table
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Jing Tao
+     *
      *   '$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;
     /**
      * A class express a entry in xml_replication. It include server name,
      * lastChechedDate, replication or not, dataReplication or not, hub or not
      */
     public class ReplicationServer
+    {
       private String serverName = null; //server name
       private String lastCheckedDate = null; //string of last
       private boolean replication = false; //replciate xml document or not
       private boolean dataReplication = false; //replciate data file or not
                                                //it is relative to replcation
                                                //if replication is false, it should
                                                //be false
       private boolean hub = false; //it is hub or not. Hub means the localhost can
                                    //replcate documents to the server if the
                                    //document's home server is not localhost
       /**
        * Consturctor of ReplicationServer
        */
       public ReplicationServer()
+      {
         this.serverName = null;
         this.lastCheckedDate = null;
         this.replication = false;
         this.dataReplication = false;
         this.hub = false;
       }//constructor
       /**
        * Get server name
        */
       public String getServerName()
+      {
         return this.serverName;
       }//getServerName
       /**
        * Set a sting as server name
        * @param myServerName, the string will set to object's serverName
        */
       public void setServerName(String myServerName)
+      {
         this.serverName = myServerName;
       }//setServerName
       /**
        * Get last checked date
        */
       public String getLastCheckedDate()
+      {
         return this.lastCheckedDate;
       }//getLastCheckedDate
       /**
        * Set a string as last checked date
        * @Param myLastCheckedDate, the string will set to object's lastCheckedDate
        */
       public void setLastCheckedDate(String myLastCheckedDate)
+      {
         this.lastCheckedDate = myLastCheckedDate;
       }//setLastCheckedDate
       /**
        * Get replication xml or not option
        */
       public boolean getReplication()
+      {
         return this.replication;
       }//getReplication
       /**
        * Set replication option
        * @param myReplication, the option will set to object's replication
        */
       public void setReplication(boolean myReplication)
+      {
         this.replication = myReplication;
       }//setReplication
       /**
        * Get datareplication xml or not option
        */
       public boolean getDataReplication()
+      {
         return this.dataReplication;
       }//getDataReplication
       /**
        * Set data replication option
        * @param myDataReplication, the option will set to object's datareplication
        */
       public void setDataReplication(boolean myDataReplication)
+      {
         this.dataReplication = myDataReplication;
       }//setDataReplication
       /**
        * Get hub option
        */
       public boolean getHub()
+      {
         return this.hub;
       }//getHub
       /**
        * Set hub option
        * @param myHub, the option will set to object's hub option
        */
       public void setHub(boolean myHub)
+      {
         this.hub = myHub;
       }//setHub
     }//class ReplicationServer

     /**
      *  '$RCSfile$'
      *    Purpose: A class to asyncronously force the replication of each server
      *             that has an entry in the xml_replication table.  When run,
      *             this thread communicates with each server in the list and
      *             solicites a read of an updated or newly inserted document
      *             with a certain docid.
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Chad Berkley
+     *
      *   '$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.util.*;
     import java.io.*;
     import java.sql.*;
     import java.net.*;
     import java.lang.*;
     import java.text.*;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.util.MetacatUtil;
     /**
      * A class to asyncronously force the replication of each server
      * that has an entry in the xml_replication table.  When run,
      * this thread communicates with each server in the list and
      * solicites a read of an updated or newly inserted document
      * with a certain docid.
      */
     public class ForceReplicationHandler implements Runnable
+    {
       private Thread btThread;
       private String docid;
       private String action;
       private boolean xmlDocument;
       private boolean dbactionFlag = true;
       private ReplicationServerList serverLists = null;//Serverlist
       private int homeServerCode = 0; // home server code for the docid
       // When a metacat A got forcereplication
       // notification from B, then A will update its record. And A will notification
       // other metacat in its serverlist to update this docid if A is a hub. But we
       // don't want A to notify B again. B is nofitification of A
       private String notificationServer = null;
       private Logger logMetacat = Logger.getLogger(ForceReplicationHandler.class);
       //constant
       public static final String DELETE = "delete";
       /**
        * Constructor of ForceReplicationHandler
        * @param docid the docid to force replicate
        * @param the action that is being performed on the document (either
        *        INSERT or UPDATE)
        * @param xml the docid is a xml document or not (data file)
        * @param notificationServer, when a metacat A got forcereplication
        * notification from B, then A will update its record. And A will notification
        * other metacat in its serverlist to update this docid if A is a hub. But we
        * don't want A to notify B again. B is nofitification of A.
        */
       public ForceReplicationHandler(String docid, String action, boolean xml,
                                                        String myNotificationServer)
+      {
         this.docid = docid;
         this.action = action;
         this.xmlDocument =xml;
         // Build a severLists from xml_replication table
         this.serverLists = new ReplicationServerList();
         // Get sever code for this docid
         try
+        {
           this.homeServerCode = MetacatReplication.getHomeServerCodeForDocId(docid);
         }//try
         catch (Exception e)
+        {
           logMetacat.error("Error in ForceReplicationHandle(): "
                                                               +e.getMessage());
         }//catch
         // Get the notification server
         this.notificationServer = myNotificationServer;
         if(this.action.equals(""))
+        {
           dbactionFlag = false;
+        }
         btThread = new Thread(this);
         btThread.setPriority(Thread.MIN_PRIORITY);
         btThread.start();
+      }
       /**
        * Use this constructor when the action is implied.
        */
       public ForceReplicationHandler(String docid, boolean xml,
                                                     String myNotificationServer )
+      {
         this.docid = docid;
         this.xmlDocument = xml;
         dbactionFlag = false;
         // Build a severLists from xml_replication table
         this.serverLists = new ReplicationServerList();
         // Get home server code for this doicd
         try
+        {
           this.homeServerCode = MetacatReplication.getHomeServerCodeForDocId(docid);
+        }
          catch (Exception e)
+        {
           logMetacat.error("Error in ForceReplicationHandle(): "
                                                               +e.getMessage());
         }//catch
         // Get notification server
         this.notificationServer = myNotificationServer;
         btThread = new Thread(this);
         btThread.setPriority(Thread.MIN_PRIORITY);
         btThread.start();
+      }
       /**
        * Method to send force replication command to other server to get
        * a new or updated docid
        */
       public void run()
+      {
     	    // URL for notifcation
     	    URL comeAndGetIt = null;
     		// If no server in xml_replication table, metacat don't need do anything
     		if (serverLists.isEmpty()) {
     			return;
+    		}
     		// Thread seelping for some seconds to make sure the document was insert
     		// into the database before we send force replication request
     		int sleepTime;
     		try {
     			sleepTime = Integer.parseInt(PropertyService
     					.getProperty("replication.forcereplicationwaitingtime"));
     			Thread.sleep(sleepTime);
     		} catch (Exception ee) {
     			logMetacat.error("Couldn't sleep in force replication");
+    		}
     		logMetacat.info("notification server:" + notificationServer);
     		// Check every server in the serverlists
     		for (int i = 0; i < serverLists.size(); i++) {
     			//Set comeAndGetIt null
     			comeAndGetIt = null;
     			// Get ReplicationServer object in index i
     			ReplicationServer replicationServer = serverLists.serverAt(i);
     			// Get this ReplicationServer 's name
     			String server = replicationServer.getServerName();
     			try {
     				// If the server is the notification server, we don't notify it back
     				// again, if server is null we don't replication it
     				if (server != null && !server.equals(notificationServer)) {
     					if (dbactionFlag) {
     						// xml documents and server can replicate xml doucment
     						if (xmlDocument && replicationServer.getReplication()) {
     							// If this docid's homeserver is localhost, replicate it
     							if (homeServerCode == 1) {
     								MetacatReplication.replLog("force xml replicating to "
     										+ server);
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicate&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid + "&dbaction=" + action);
     								//over write the url for delete
     								if (action != null && action.equals(DELETE)) {
     									comeAndGetIt = new URL("https://" + server
     											+ "?action="
     											+ MetacatReplication.FORCEREPLICATEDELETE
     											+ "&docid=" + docid + "&server="
     											+ MetacatUtil.getLocalReplicationServerName());
+    								}
     							}//if servercode==1
     							else if (replicationServer.getHub()
     									|| server.equals(MetacatReplication
     											.getServerNameForServerCode(homeServerCode))) {
     								// If the docid's home server is not local host, but local host
     								// is a hub of this server, replicate the docid too.
     								// If the server is homeserver of the docid, replication it too
     								MetacatReplication.replLog("force xml replicating to "
     										+ server);
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicate&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid + "&dbaction=" + action);
     								//over write the url for delete
     								if (action != null && action.equals(DELETE)) {
     									comeAndGetIt = new URL("https://" + server
     											+ "?action="
     											+ MetacatReplication.FORCEREPLICATEDELETE
     											+ "&docid=" + docid + "&server="
     											+ MetacatUtil.getLocalReplicationServerName());
+    								}
     							}//else
     						}//if xmlDocument
     						//It is data file and configured to handle data replication
     						else if (replicationServer.getDataReplication()) {
     							// If the docid's home server is local host, replicate the docid
     							if (homeServerCode == 1) {
     								MetacatReplication.replLog("force data replicating to "
     										+ server);
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicatedatafile&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid + "&dbaction=" + action);
     								//over write the url for delete
     								if (action != null && action.equals(DELETE)) {
     									comeAndGetIt = new URL("https://" + server
     											+ "?action="
     											+ MetacatReplication.FORCEREPLICATEDELETE
     											+ "&docid=" + docid + "&server="
     											+ MetacatUtil.getLocalReplicationServerName());
+    								}
     							}//if serverCode==1
     							else if (replicationServer.getHub()
     									|| server.equals(MetacatReplication
     											.getServerNameForServerCode(homeServerCode))) {
     								// If the docid's home server is not local host, but local host
     								// is a hub of this server, replicate the docid too.
     								// If the server is homeserver of the docid replication it too
     								MetacatReplication.replLog("force data replicating to "
     										+ server);
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicatedatafile&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid + "&dbaction=" + action);
     								//over write the url for delete
     								if (action != null && action.equals(DELETE)) {
     									comeAndGetIt = new URL("https://" + server
     											+ "?action="
     											+ MetacatReplication.FORCEREPLICATEDELETE
     											+ "&docid=" + docid + "&server="
     											+ MetacatUtil.getLocalReplicationServerName());
+    								}
     							}//else if servercode==1
     						}//else if data file
     					}//if has explicite action
     					else { // has implicite action
     						MetacatReplication
     								.replLog("force replicating (default action) to )"
     										+ server);
     						// this docid is xml documents and can replicate xml doucment
     						if (xmlDocument && replicationServer.getReplication()) {
     							// If homeserver of this doicd is local, replicate it
     							if (homeServerCode == 1) {
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicate&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid);
     							}//if homeserver ==1
     							else if (replicationServer.getHub()
     									|| server.equals(MetacatReplication
     											.getServerNameForServerCode(homeServerCode))) {
     								// If home server of this docid is not local host, but local
     								// host is a hub for this server, replicate this doicd
     								// If the server is homeserver of the docid, replication it too
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicate&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid);
     							}//else if
     						}//if xmlDoucment
     						else if (replicationServer.getDataReplication()) { //It is datafile and server is configured to replicate data file
     							//if home server is local host, replicate the data file
     							if (homeServerCode == 1) {
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicatedatafile&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid);
     							}//if
     							else if (replicationServer.getHub()
     									|| server.equals(MetacatReplication
     											.getServerNameForServerCode(homeServerCode))) {
     								// If home server is not local host, but the local host is a hub
     								// For this server, replicate the data file
     								// If the server is homeserver of the docid, replication it too
     								comeAndGetIt = new URL("https://" + server
     										+ "?action=forcereplicatedatafile&server="
     										+ MetacatUtil.getLocalReplicationServerName()
     										+ "&docid=" + docid);
     							}//else
     						}//else if
     					}//else has implicit action
     					//Make sure comeAndGetIt is not empty
     					if (comeAndGetIt != null && !comeAndGetIt.equals("")) {
     						logMetacat.warn("sending message: " + comeAndGetIt.toString());
     						String message = MetacatReplication.getURLContent(comeAndGetIt);
+    					}
     					//send out the url.  message is a dummy variable as the target of
     					//the URL never directly replies to the request.  this simply
     					//invoces a read request from the server to this local machine.
     				}//if notification server
     			} catch (Exception ee) {
     				logMetacat.error("error in ForceReplicationHandler.run for server "
     						+ server + " " + ee.getMessage());
     				ee.printStackTrace();
+    			}
     		}//for
     		logMetacat.warn("exiting ForceReplicationHandler Thread");
     	}//run
     }//ForceReplication class

     /**
      *  '$RCSfile$'
      *    Purpose: A class that handles xml messages passed by the
      *             replication handler
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Chad Berkley
+     *
      *   '$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.util.Vector;
     import org.xml.sax.Attributes;
     import org.xml.sax.SAXException;
     import org.xml.sax.helpers.DefaultHandler;
     /**
      * A Class implementing callback bethods for the SAX parser to
      * call when processing the XML messages from the replication handler
      */
     public class ReplMessageHandler extends DefaultHandler
+    {
       private Vector updates = new Vector();
       private Vector indivUpdate = new Vector();
       private Vector indivDelete = new Vector();
       private Vector indivRevision = new Vector();
       private Vector deletes = new Vector();
       private Vector revisions = new Vector();
       private String server;
       private String dataFile;
       private boolean update = false;
       private boolean delete = false;
       private boolean revision = false;
       String currentTag = new String();
       StringBuffer textBuffer = null;
       public ReplMessageHandler()
+      {
+      }
       /**
        * This method starts a new vector for each updatedDocument tag.
        */
       public void startElement(String uri, String localName, String qName,
                                Attributes attributes) throws SAXException
+      {
         textBuffer = new StringBuffer();
         currentTag = localName;
         if(localName.equals("updatedDocument"))
+        {
           indivUpdate = new Vector();
           update = true;
+        }
         else if(localName.equals("deletedDocument"))
+        {
           indivDelete = new Vector();
           delete = true;
+        }
         else if (localName.equals("revisionDocument"))
+        {
           indivRevision = new Vector();
           revision = true;
+        }
+      }
       /**
        * This method write the indivUpdate to updates when it finds the end of
        */
       public void endElement(String uri, String localName, String qName)
                   throws SAXException
+      {
         if(currentTag.equals("docid") && update)
+        {
           indivUpdate.add(textBuffer.toString());
+        }
         else if(currentTag.equals("docid") && delete)
+        {
           indivDelete.add(textBuffer.toString());
+        }
         else if (currentTag.equals("docid") && revision)
+        {
           indivRevision.add(textBuffer.toString());
+        }
         if(currentTag.equals("rev") && update)
+        {
           indivUpdate.add(textBuffer.toString());
           indivUpdate.add(server);
+        }
         else if(currentTag.equals("rev") && delete)
+        {
           indivDelete.add(textBuffer.toString());
           indivDelete.add(server);
+        }
         else if(currentTag.equals("rev") && revision)
+        {
           indivRevision.add(textBuffer.toString());
           indivRevision.add(server);
+        }
         if(currentTag.equals("date_updated") && update)
+        {
           indivUpdate.add(textBuffer.toString());
           indivUpdate.add(server);
+        }
         else if(currentTag.equals("date_updated") && delete)
+        {
           indivDelete.add(textBuffer.toString());
           indivDelete.add(server);
+        }
         else if(currentTag.equals("date_updated") && revision)
+        {
           indivRevision.add(textBuffer.toString());
           indivRevision.add(server);
+        }
         if(currentTag.equals("server"))
+        {
           server = textBuffer.toString();
+        }
         //Adding data file attribute into indivUpdate vector
         if (currentTag.equals("datafile"))
+        {
           dataFile = textBuffer.toString();
           if (update)
+          {
             indivUpdate.add(dataFile);
+          }
           else if (revision)
+          {
             indivRevision.add(dataFile);
+          }
+        }
         if(localName.equals("updatedDocument"))
+        {
           updates.add(new Vector(indivUpdate));
           update = false;
+        }
         else if(localName.equals("deletedDocument"))
+        {
           deletes.add(new Vector(indivDelete));
           delete = false;
+        }
         else if (localName.equals("revisionDocument"))
+        {
            revisions.add(new Vector(indivRevision));
            revision = false;
+        }
+      }
       /**
        * Take the data out of the docid and date_updated fields
        */
       public void characters(char[] ch, int start, int length) throws SAXException
+      {
         textBuffer.append(new String(ch, start,length));
+      }
       public Vector getUpdatesVect()
+      {
         return updates;
+      }
       public Vector getDeletesVect()
+      {
         return deletes;
+      }
       public Vector getRevisionsVect()
+      {
          return revisions;
+      }
       /**
        * Gets the server name
        * @return
        */
       public String getServerName()
+      {
     	  return server;
+      }
+    }

     /**
      *  '$RCSfile$'
      *    Purpose: A class represent a replication server list in
                    xml_replcation table
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Jing Tao
+     *
      *   '$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 edu.ucsb.nceas.metacat.service.DatabaseService;
     import java.util.Vector;
     import java.sql.*;
     import org.apache.log4j.Logger;
     /**
      * A class represent a replication server list in xml_replcation table
      */
     public class ReplicationServerList
+    {
       private static Vector serverList = null; //Vector to store server list
       private static Logger logMetacat = Logger.getLogger(ReplicationServer.class);
       /**
        * constructor of ReplicationServerList
        * It will build server list. If only local host exists, ther server list
        * will be null
        */
       public ReplicationServerList()
+      {
         serverList = new Vector();
         //Build serverList
         buildServerList();
       }//ReplicationServerList
       /**
        * Method to create server list from xml_replication table
        * If in xml_replication table, only local host exists, server list will be
        * empty
        */
       private void buildServerList()
+      {
         ReplicationServer server = null; //element in server list
         DBConnection dbConn = null;//DBConnection
         int serialNumber = -1;//DBConnection serial number
         PreparedStatement pstmt = null;
         ResultSet rs = null;
         boolean hasReplication = false;//Replication xml or not
         boolean hasDataReplication = false;//Replication data file or not
         boolean isHub = false;//local host is the hub for this server or not
         try
+        {
           //Get DBConnection
           dbConn=DBConnectionPool.
                       getDBConnection("ReplicationHandler.buildServerList");
           serialNumber=dbConn.getCheckOutSerialNumber();
           //Select fields from xml_replication table
           pstmt = dbConn.prepareStatement("select server, last_checked, replicate,"+
                         " datareplicate, hub from xml_replication");
           //Execute prepare statement
           pstmt.execute();
           //Get result set
           rs = pstmt.getResultSet();
           //Iterate over the result set
           boolean tableHasRows = rs.next();
           while(tableHasRows)
+          {
             //Server name
             String serverName = rs.getString(1);
             logMetacat.info("ServerName: "+serverName);
             //Last check date
             String lastChecked = rs.getString(2);
             logMetacat.info("Last checked time: "+lastChecked);
             //Replication value
             int replication = rs.getInt(3);
             logMetacat.info("Replication value: "+replication);
             //Data replication value
             int dataReplication = rs.getInt(4);
             logMetacat.info("DataReplication value: "+dataReplication);
             //Hub value
             int hubValue = rs.getInt(5);
             logMetacat.info("Hub value: "+hubValue);
             //Get rid of local host
             if(!serverName.equals("localhost"))
+            {
               //create a new object of Replication
               server = new ReplicationServer();
               //Set server name
               server.setServerName(serverName);
               //Set last check date
               server.setLastCheckedDate(lastChecked);
               //From replication value to determine hasReplication valuse
               if (replication ==1)
+              {
                 //If replication equals 1, it can replicate xml documents
                 hasReplication = true;
               }//if
               else
+              {
                 //if replication is NOT 1, it can't replicate xml documents
                 hasReplication = false;
               }//else
               //Set replication value
               server.setReplication(hasReplication);
               //From both replication and data replication value to determine
               //hasDataReplication value
               if (hasReplication && dataReplication ==1)
+              {
                 //Only server can replicate xml (hasRplication == true) and
                 // dataReplication is 1, local host can replicate data file
                 hasDataReplication = true;
               }//if
               else
+              {
                 hasDataReplication = false;
               }//else
               //Set data replciation value
               server.setDataReplication(hasDataReplication);
               //Detemine isHub by hubValue
               if (hubValue ==1)
+              {
                 isHub = true;
               }//if
               else
+              {
                 isHub = false;
               }//else
               //Set hub value
               server.setHub(isHub);
               //Add this server into server list
               serverList.add(server);
             }//if
             //Go to new row
             tableHasRows = rs.next();
           }//while
         }//try
         catch(Exception e)
+        {
           logMetacat.error("Error in ReplicationServerList."
                                         +"buildServerList(): "+e.getMessage());
         }//catch
         finally
+        {
           try
+          {
             //close result set
             rs.close();
             //close prepareed statement
             pstmt.close();
           }//try
           catch (SQLException sqlE)
+          {
             logMetacat.error("Error in ReplicationHandler.buildServerList: "
                                     +sqlE.getMessage());
           }//catch
           finally
+          {
             //Return dbconnection too pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
           }//finally
         }//finally
       }//buildServerList
       /**
        * Method to determine the server list is empty or not
        */
       public boolean isEmpty()
+      {
         return serverList.isEmpty();
       }//isEmpty
       /**
        * Method to get the size of serverList
        */
       public int size()
+      {
         return serverList.size();
       }//size()
       /**
        * Method to add a new replciation server object to serverList
        * @Param newReplciationServer, the object need to be add
        */
       private synchronized void addNewReplicationServer
                                           (ReplicationServer newReplicationServer)
+      {
         serverList.add(newReplicationServer);
       }//addNewReplicationServer
       /**
        * Method to get a server object given a index number
        * @param index, the given index number
        */
       public ReplicationServer serverAt(int index)
+      {
         return (ReplicationServer)serverList.elementAt(index);
       }//serverAt
       /**
        * Method to determine if a given server in the replication server list
        * @param givenServerName, a server name will be check.
        */
       public boolean isGivenServerInList(String givenServerName)
+      {
         boolean result = false;//Variable store the return value
         ReplicationServer server = null; //Element in vetor
         int size = 0;//Variable to store the size of vector serverList
         //Get the size of vector
         size = serverList.size();
         //If server list is empty
         if (size == 0||givenServerName == null||givenServerName.equals(""))
+        {
           result = false;
           return result;
+        }
         //Check every element in the vector
         for (int i = 0; i < size; i++)
+        {
           //Get the ReplicationServer object indexed i in vector
           server = (ReplicationServer) serverList.elementAt(i);
           //If given name match a server's name, return true
           if ( givenServerName.equalsIgnoreCase(server.getServerName()))
+          {
             result = true;
             return result;
           }//if
         }//for
         //If reach here, there is no server's name match the given name
         //flase will return
         return result;
       }//isGinvenServerInList
       /**
        * Method to determine its index in server list for a given server.
        * If couldn't find it, -1 will be returned
        * @param givenServerName, a server name will be check.
        */
       private synchronized int findIndexInServerList(String givenServerName)
+      {
         int index = -1;//Variable store the return value
         ReplicationServer server = null; //Element in vetor
         int size = 0;//Variable to store the size of vector serverList
         //Get the size of vector
         size = serverList.size();
         //If server list is empty, -1 will be returned
         if (size == 0 || givenServerName ==null ||givenServerName.equals(""))
+        {
           return index;
+        }
         //Check every element in the vector
         for (int i = 0; i < size; i++)
+        {
           //Get the ReplicationServer object indexed i in vector
           server = (ReplicationServer) serverList.elementAt(i);
           //If given name match a server's name, return true
           if ( givenServerName.equalsIgnoreCase(server.getServerName()))
+          {
             index = i;
             return index;
           }//if
         }//for
         //If reach here, there is no server's name match the given name
         //-1 will return
         return index;
       }//isGinvenServerInList
       /**
        * To a given server name, try to get its lastcheck date.
        * If couldn't find the server in the server list, null will return
        * @param givenServerName, the server's name which we want to get last checked
        * out date
        */
       public synchronized String getLastCheckedDate(String givenServerName)
+      {
         int index = -1;//Variable to store the index
         ReplicationServer server = null;//Variable for replication server
         //Get the server's index in server list
         index = findIndexInServerList(givenServerName);
         //If index = -1, couldn't find this server, null will return
         if (index == -1)
+        {
           return null;
         }//if
         //Get Replication server object
         server = (ReplicationServer) serverList.elementAt(index);
         //return its lastcheckeddate attributes in this object
         return server.getLastCheckedDate();
       }//getLastCehckedDate
       /**
        * To a given server name, try to get its xml replciation option
        * If couldn't find the server in the server list, false will return
        * @param givenServerName, the server's name which we want to get replication
        * value
        */
       public synchronized boolean getReplicationValue(String givenServerName)
+      {
         int index = -1;//Variable to store the index
         ReplicationServer server = null;//Variable for replication server
         //Get the server's index in server list
         index = findIndexInServerList(givenServerName);
         //If index = -1, couldn't find this server, null will return
         if (index == -1)
+        {
           return false;
         }//if
         //Get Replication server object
         server = (ReplicationServer) serverList.elementAt(index);
         //return this object's replication value
         return server.getReplication();
       }//getReplicationValue
       /**
        * To a given server name, try to get its data file replciation option
        * If couldn't find the server in the server list, false will return
        * @param givenServerName, the server's name which we want to get data file
        * replication value
        */
       public synchronized boolean getDataReplicationValue(String givenServerName)
+      {
         int index = -1;//Variable to store the index
         ReplicationServer server = null;//Variable for replication server
         //Get the server's index in server list
         index = findIndexInServerList(givenServerName);
         //If index = -1, couldn't find this server, null will return
         if (index == -1)
+        {
           return false;
         }//if
         //Get Replication server object
         server = (ReplicationServer) serverList.elementAt(index);
         //Return this object's data replication value
         return server.getDataReplication();
       }//getDataReplicationValue
       /**
        * To a given server name, try to get its hub option
        * If couldn't find the server in the server list, false will return
        * @param givenServerName, the server's name which we want to get hub
        */
       public synchronized boolean getHubValue(String givenServerName)
+      {
         int index = -1;//Variable to store the index
         ReplicationServer server = null;//Variable for replication server
         //Get the server's index in server list
         index = findIndexInServerList(givenServerName);
         //If index = -1, couldn't find this server, null will return
         if (index == -1)
+        {
           return false;
         }//if
         //Get Replication server object
         server = (ReplicationServer) serverList.elementAt(index);
         //Return this object's hub value
         return server.getHub();
       }//getHubValue
       /**
        * To a given server name, to check if it is in the server list.
        * If it is not, add it to server list and the xml_replication table
        * This method is for a document was replicated by a hub and the document's
        * home server is not in the replication table. The value for replicate,
        * datareplicate and hub are all false
        * @param givenServerName, the server's name which want to check
        */
       public synchronized void addToServerListIfItIsNot(String givenServerName)
+      {
         // Variable to store the index for the givenServerName
         int index = -1;
         // Variable to store the new replciation server object
         ReplicationServer newServer = null;
         // For sql command
         PreparedStatement pStmt=null;
         // For check out DBConnection
         DBConnection dbConn = null;
         int serialNumber = -1;
         // Field value for xml_replication table
         int replicate = 0;
         int dataReplicate = 0;
         int hub = 0;
         // Get the the index
         index = findIndexInServerList(givenServerName);
         // if index ==-1, it not in the server list
         // Add the server to server list
         // Add the server to xml_replication table
         if (index ==-1)
+        {
           // Create a new replication server object it's replicate, datareplicate
           // and hub values are default - false
           newServer = new ReplicationServer();
           // Set newServer's name as givenServerName
           newServer.setServerName(givenServerName);
           // Add newServer to serverList
           this.addNewReplicationServer(newServer);
           // Add this server to xml_table too
          try
+          {
             // Checkout DBConnection
             dbConn=DBConnectionPool.
                  getDBConnection("ReplicationSErverList.addToServerListIfItIsNot");
             serialNumber=dbConn.getCheckOutSerialNumber();
             // Inser it into xml_replication table
             /*pStmt = dbConn.prepareStatement("INSERT INTO xml_replication " +
                           "(server, last_checked, replicate, datareplicate, hub) "+
                            "VALUES ('" + givenServerName + "', to_date(" +
                            "'01/01/00', 'MM/DD/YY'), '" +
                            replicate +"', '"+dataReplicate+"','"+ hub + "')");*/
             pStmt = dbConn.prepareStatement("INSERT INTO xml_replication " +
                           "(server, last_checked, replicate, datareplicate, hub) "+
                            "VALUES ('" + givenServerName + "', "+
                             DatabaseService.getDBAdapter().toDate("01/01/1980","MM/DD/YYYY") + ", '" +
                            replicate +"', '"+dataReplicate+"','"+ hub + "')");
             pStmt.execute();
             pStmt.close();
           }//try
           catch (Exception e)
+          {
             logMetacat.error("Error in ReplicationServerList."+
                                 "addToServerListIfItIsNot: " + e.getMessage());
           }//catch
           finally
+          {
             try
+            {
               pStmt.close();
             }//try
             catch (Exception ee)
+            {
               logMetacat.error("Error in ReplicationServerList."+
                                 "addToServerListIfItIsNot: " + ee.getMessage());
             }//catch
             finally
+            {
               DBConnectionPool.returnDBConnection(dbConn, serialNumber);
             }//finally
           }//finally
         }//if
       }//addToServerListIfItIsNot
     }//ReplicationServerList

     /**
      *  '$RCSfile$'
      *    Purpose: A class to asyncronously do delta-T replication checking
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Chad Berkley
+     *
      *   '$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 edu.ucsb.nceas.metacat.service.DatabaseService;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.util.MetacatUtil;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     import java.sql.*;
     import java.util.*;
     import java.util.Date;
     import java.lang.Thread;
     import java.io.*;
     import java.net.*;
     import java.text.*;
     import org.apache.log4j.Logger;
     import org.xml.sax.AttributeList;
     import org.xml.sax.ContentHandler;
     import org.xml.sax.DTDHandler;
     import org.xml.sax.EntityResolver;
     import org.xml.sax.ErrorHandler;
     import org.xml.sax.InputSource;
     import org.xml.sax.XMLReader;
     import org.xml.sax.SAXException;
     import org.xml.sax.SAXParseException;
     import org.xml.sax.helpers.XMLReaderFactory;
     import org.xml.sax.helpers.DefaultHandler;
     /**
      * This class handles deltaT replication checking.  Whenever this TimerTask
      * is fired it checks each server in xml_replication for updates and updates
      * the local db as needed.
      */
     public class ReplicationHandler extends TimerTask
+    {
       int serverCheckCode = 1;
       ReplicationServerList serverList = null;
       //PrintWriter out;
     //  private static final AbstractDatabase dbAdapter = MetacatUtil.dbAdapter;
       private static Logger logMetacat = Logger.getLogger(ReplicationHandler.class);
       private static int DOCINSERTNUMBER = 1;
       private static int DOCERRORNUMBER  = 1;
       private static int REVINSERTNUMBER = 1;
       private static int REVERRORNUMBER  = 1;
       public ReplicationHandler()
+      {
         //this.out = o;
         serverList = new ReplicationServerList();
+      }
       public ReplicationHandler(int serverCheckCode)
+      {
         //this.out = o;
         this.serverCheckCode = serverCheckCode;
         serverList = new ReplicationServerList();
+      }
       /**
        * Method that implements TimerTask.run().  It runs whenever the timer is
        * fired.
        */
       public void run()
+      {
         //find out the last_checked time of each server in the server list and
         //send a query to each server to see if there are any documents in
         //xml_documents with an update_date > last_checked
         try
+        {
           //if serverList is null, metacat don't need to replication
           if (serverList==null||serverList.isEmpty())
+          {
             return;
+          }
           updateCatalog();
           update();
           //conn.close();
         }//try
         catch (Exception e)
+        {
           logMetacat.error("Error in replicationHandler.run():"
                                                         +e.getMessage());
           e.printStackTrace();
         }//catch
+      }
       /**
        * Method that uses revision taging for replication instead of update_date.
        */
       private void update()
+      {
         /*
          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)
         */
         ReplicationServer replServer = null; // Variable to store the
                                             // ReplicationServer got from
                                             // Server list
         String server = null; // Variable to store server name
         String update;
         Vector responses = new Vector();
         URL u;
         //Check for every server in server list to get updated list and put
         // them in to response
         for (int i=0; i<serverList.size(); i++)
+        {
             // Get ReplicationServer object from server list
             replServer = serverList.serverAt(i);
             // Get server name from ReplicationServer object
             server = replServer.getServerName().trim();
             String result = null;
             MetacatReplication.replLog("full update started to: " + server);
             // Send command to that server to get updated docid information
             try
+            {
               u = new URL("https://" + server + "?server="
               +MetacatUtil.getLocalReplicationServerName()+"&action=update");
               logMetacat.info("Sending infomation " +u.toString());
               result = MetacatReplication.getURLContent(u);
+            }
             catch (Exception e)
+            {
               MetacatReplication.replErrorLog("Failed to get updated doc list "+
                               "for server " + server + " because "+e.getMessage());
               logMetacat.error( "Failed to get updated doc list "+
                            "for server " + server + " because "+e.getMessage());
               continue;
+            }
             logMetacat.info("docid: "+server+" "+result);
             //check if result have error or not, if has skip it.
             if (result.indexOf("<error>")!=-1 && result.indexOf("</error>")!=-1)
+            {
               MetacatReplication.replErrorLog("Failed to get updated doc list "+
                               "for server " + server + " because "+result);
               logMetacat.info( "Failed to get updated doc list "+
                            "for server " + server + " because "+result);
               continue;
+            }
             //Add result to vector
             responses.add(result);
+        }
         //make sure that there is updated file list
         //If response is null, metacat don't need do anything
         if (responses==null || responses.isEmpty())
+        {
             MetacatReplication.replErrorLog("No updated doc list for "+
                                "every server and failed to replicate");
             logMetacat.info( "No updated doc list for "+
                                "every server and failed to replicate");
             return;
+        }
         logMetacat.info("Responses from remote metacat about updated "+
                        "document information: "+ responses.toString());
         // go through response vector(it contains updated vector and delete vector
         for(int i=0; i<responses.size(); i++)
+        {
         	XMLReader parser;
         	ReplMessageHandler message = new ReplMessageHandler();
         	try
+            {
               parser = initParser(message);
+            }
             catch (Exception e)
+            {
               MetacatReplication.replErrorLog("Failed to replicate becaue couldn't "+
                                          " initParser for message and" +e.getMessage());
               logMetacat.error("Failed to replicate becaue couldn't " +
                                     " initParser for message and " +e.getMessage());
                // stop replication
                return;
+            }
             try
+            {
               parser.parse(new InputSource(
                          new StringReader(
                          (String)(responses.elementAt(i)))));
+            }
             catch(Exception e)
+            {
               MetacatReplication.replErrorLog("Couldn't parse one responses "+
                                "because "+ e.getMessage());
               logMetacat.error("Couldn't parse one responses "+
                                        "because "+ e.getMessage());
               continue;
+            }
             //v is the list of updated documents
             Vector updateList = new Vector(message.getUpdatesVect());
             MetacatReplication.replLog("The document list size is "+updateList.size()+ " from "+message.getServerName());

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 5014

Added by daigle over 15 years ago