Metacat

	/**

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

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

	 * store it in local database.

	 */

	protected static void handleForceReplicateSystemMetadataRequest(

			Hashtable<String, String[]> params, HttpServletResponse response,

			HttpServletRequest request) {

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

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

		try {

			logReplication.info("ReplicationService.handleForceReplicateSystemMetadataRequest - Force replication system metadata request from: " + server);

			// get the system metadata from server

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

					+ MetacatUtil.getLocalReplicationServerName()

					+ "&action=getsystemmetadata&guid=" + guid);

			String systemMetadataXML = ReplicationService.getURLContent(docinfourl);

			// process system metadata

			if (systemMetadataXML != null) {

				SystemMetadata sysMeta = 

					(SystemMetadata) ServiceTypeUtil.deserializeServiceType(

							SystemMetadata.class,

							new ByteArrayInputStream(systemMetadataXML.getBytes("UTF-8")));

				if (!IdentifierManager.getInstance().identifierExists(guid)) {

					logReplication.debug("Creating system metadata for guid: " + guid);

					IdentifierManager.getInstance().createSystemMetadata(sysMeta);

				}

				IdentifierManager.getInstance().updateSystemMetadata(sysMeta);

			}

			logReplication.info("ReplicationService.handleForceReplicateSystemMetadataRequest - processed guid: " + guid);

			EventLog.getInstance().log(request.getRemoteAddr(), REPLICATIONUSER, guid, "systemMetadata");

		} catch (Exception e) {

			logMetacat.error("ReplicationService.handleForceReplicateRequest - " + ReplicationService.METACAT_REPL_ERROR_MSG, e);                         

			logReplication.error("ReplicationService.handleForceReplicateRequest - General error when processing guid: " + guid, e);

		}

	}

/**

 *  '$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: daigle $'

 *     '$Date: 2009-08-24 13:34:17 -0800 (Mon, 24 Aug 2009) $'

 * '$Revision: 5030 $'

 *

 * 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.replication;

import java.net.URL;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.util.MetacatUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * 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

 * forces replication of system metadata

 */

public class ForceReplicationSystemMetadataHandler implements Runnable

{

  private Thread btThread;

  private String guid;

  private ReplicationServerList serverLists = null;

  private String notificationServer = null;

  private static Logger logReplication = Logger.getLogger("ReplicationLogging");

  private static Logger logMetacat = Logger.getLogger(ForceReplicationSystemMetadataHandler.class);

  /**

   * Use this constructor when the action is implied.

   */

  public ForceReplicationSystemMetadataHandler(String docid, boolean xml,

                                                String myNotificationServer )

  {

    this.guid = docid;

    // Build a severLists from xml_replication table

    this.serverLists = new ReplicationServerList();

    // 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 notification

	    URL comeAndGetIt = null;

		// If no server in xml_replication table we are done

		if (serverLists.isEmpty()) {

			return;

		}

		// Thread sleeping 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 (PropertyNotFoundException pnfe) {

	    	logMetacat.error(ReplicationService.METACAT_REPL_ERROR_MSG);

			logReplication.error("Property error: " + pnfe.getMessage());

		} catch (InterruptedException ie) {

	    	logMetacat.error(ReplicationService.METACAT_REPL_ERROR_MSG);

			logReplication.error("Thread sleep error: " + ie.getMessage());

		}

		logReplication.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 replicate to

				if (server != null && !server.equals(notificationServer)) {

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

							+ "?action=forcereplicatesystemmetadata"

							+ "&guid=" + guid + "&server="

							+ MetacatUtil.getLocalReplicationServerName());

					// Make sure comeAndGetIt is not empty

					if (comeAndGetIt != null && !comeAndGetIt.equals("")) {

						logReplication.warn("Sending message: " + comeAndGetIt.toString());

						String message = ReplicationService.getURLContent(comeAndGetIt);

					}

				}

			} catch (Exception e) {

		    	logMetacat.error(ReplicationService.METACAT_REPL_ERROR_MSG, e);

				logReplication.error("Error forcing System Metadata replication");

			}

		}

		logReplication.warn("Exiting Forced System Metadata Thread");

	}

}

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

				ReplicationService.handleForceReplicateSystemMetadataRequest(params, response,

						request);