Metacat

/**

 *  '$RCSfile$'

 *    Purpose: Implements a service for managing a Hazelcast cluster member

 *  Copyright: 2011 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Christopher Jones

 * 

 *   '$Author: cjones $'

 *     '$Date: 2012-01-12 07:53:58 -0800 (Thu, 12 Jan 2012) $'

 * '$Revision: 6889 $'

 *

 * 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.dataone.hazelcast;

import java.io.FileNotFoundException;

import java.util.Collection;

import java.util.Date;

import java.util.concurrent.locks.Lock;

import org.apache.log4j.Logger;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.Node;

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.SystemMetadata;

import com.hazelcast.config.Config;

import com.hazelcast.config.FileSystemXmlConfig;

import com.hazelcast.core.EntryEvent;

import com.hazelcast.core.EntryListener;

import com.hazelcast.core.Hazelcast;

import com.hazelcast.core.HazelcastInstance;

import com.hazelcast.core.IMap;

import com.hazelcast.core.ISet;

import com.hazelcast.core.InstanceEvent;

import com.hazelcast.core.InstanceListener;

import com.hazelcast.core.Member;

import com.hazelcast.partition.Partition;

import com.hazelcast.partition.PartitionService;

import com.hazelcast.query.EntryObject;

import com.hazelcast.query.Predicate;

import com.hazelcast.query.PredicateBuilder;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.dataone.D1NodeService;

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

import edu.ucsb.nceas.metacat.shared.BaseService;

import edu.ucsb.nceas.metacat.shared.ServiceException;

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * The Hazelcast service enables Metacat as a Hazelcast cluster member

 */

public class HazelcastService extends BaseService

  implements InstanceListener, EntryListener<Identifier, SystemMetadata> {

  private static final String SINCE_PROPERTY = "dateSysMetadataModified";

/* The instance of the logging class */

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

  /* The singleton instance of the hazelcast service */

  private static HazelcastService hzService = null;

  /* The Hazelcast configuration */

  private Config hzConfig;

  /* The instance of the Hazelcast client */

//  private HazelcastClient hzClient;

  /* The name of the DataONE Hazelcast cluster group */

  private String groupName;

  /* The name of the DataONE Hazelcast cluster password */

  private String groupPassword;

  /* The name of the DataONE Hazelcast cluster IP addresses */

  private String addressList;

  /* The name of the node map */

  private String nodeMap;

  /* The name of the system metadata map */

  private String systemMetadataMap;

  /* The Hazelcast distributed task id generator namespace */

  private String taskIds;

  /* The Hazelcast distributed node map */

  private IMap<NodeReference, Node> nodes;

  /* The Hazelcast distributed system metadata map */

  private IMap<Identifier, SystemMetadata> systemMetadata;

  /* The name of the identifiers set */

  private String identifiersSet;

  /* The Hazelcast distributed identifiers set */

  private ISet<Identifier> identifiers;

  private HazelcastInstance hzInstance;

  /*

   * Constructor: Creates an instance of the hazelcast service. Since

   * this uses a singleton pattern, use getInstance() to gain the instance.

   */

  private HazelcastService() {

    super();

    _serviceName="HazelcastService";

    try {

      init();

    } catch (ServiceException se) {

      logMetacat.error("There was a problem creating the HazelcastService. " +

                       "The error message was: " + se.getMessage());

    }

  }

  /**

   *  Get the instance of the HazelcastService that has been instantiated,

   *  or instantiate one if it has not been already.

   *

   * @return hazelcastService - The instance of the hazelcast service

   */

  public static HazelcastService getInstance(){

    if ( hzService == null ) {

      hzService = new HazelcastService();

    }

    return hzService;

  }

  /**

   * Initializes the Hazelcast service

   */

  public void init() throws ServiceException {

    logMetacat.debug("HazelcastService.doRefresh() called.");

	String configFileName = null;

	Config config = null;

	try {

		configFileName = PropertyService.getProperty("dataone.hazelcast.configFilePath");

		config = new FileSystemXmlConfig(configFileName);

	} catch (Exception e) {

		logMetacat.warn("Custom Hazelcast configuration not defined, using default.", e);

		configFileName = PropertyService.CONFIG_FILE_DIR + FileUtil.getFS() + "hazelcast.xml";

		// make sure we have the config

		try {

			config = new FileSystemXmlConfig(configFileName);

		} catch (FileNotFoundException e1) {

			String msg = e.getMessage();

			logMetacat.error(msg);

			throw new ServiceException(msg);

		}

	}

	Hazelcast.init(config);

  this.hzInstance = Hazelcast.getDefaultInstance();

    // Get configuration properties on instantiation

    try {

      groupName = 

        PropertyService.getProperty("dataone.hazelcast.processCluster.groupName");

      groupPassword = 

        PropertyService.getProperty("dataone.hazelcast.processCluster.password");

      addressList = 

        PropertyService.getProperty("dataone.hazelcast.processCluster.instances");

      systemMetadataMap = 

        PropertyService.getProperty("dataone.hazelcast.storageCluster.systemMetadataMap");

      identifiersSet = PropertyService.getProperty("dataone.hazelcast.storageCluster.identifiersSet");

//    nodeMap = 

//    PropertyService.getProperty("dataone.hazelcast.processCluster.nodesMap");

      // Become a DataONE-process cluster client

//      String[] addresses = addressList.split(",");

//      hzClient = 

//        HazelcastClient.newHazelcastClient(this.groupName, this.groupPassword, addresses);

//      nodes = hzClient.getMap(nodeMap);

      // Get a reference to the shared system metadata map as a cluster member

      systemMetadata = Hazelcast.getMap(systemMetadataMap);

      // Get a reference to the shared identifiers set as a cluster member

      identifiers = Hazelcast.getSet(identifiersSet);

      // Listen for changes to the system metadata map

      systemMetadata.addEntryListener(this, true);

    } catch (PropertyNotFoundException e) {

      String msg = "Couldn't find Hazelcast properties for the DataONE clusters. " +

        "The error message was: " + e.getMessage();

      logMetacat.error(msg);

    }

    // make sure we have all metadata locally

    try {

	    // add index for resynch() method

    	// can only be added once, TODO: figure out how this works

	    //systemMetadata.addIndex(SINCE_PROPERTY, true);

		//resynch();

	} catch (Exception e) {

		String msg = "Problem synchronizing system metadata. " + e.getMessage();

		logMetacat.error(msg, e);

	}

  }

  /**

   * Get the system metadata map

   * 

   * @return systemMetadata - the hazelcast map of system metadata

   * @param identifier - the identifier of the object as a string

   */

  public IMap<Identifier,SystemMetadata> getSystemMetadataMap() {

	  return systemMetadata;

  }

  /**

   * Get the identifiers set

   * @return identifiers - the set of unique DataONE identifiers in the cluster

   */

  public ISet<Identifier> getIdentifiers() {

      return identifiers;

  }

  /**

   * When Metacat changes the underlying store, we need to refresh the

   * in-memory representation of it.

   * @param guid

   */

  public void refreshSystemMetadataEntry(String guid) {

	Identifier identifier = new Identifier();

	identifier.setValue(guid);

	// force hazelcast to update system metadata in memory from the store

	HazelcastService.getInstance().getSystemMetadataMap().evict(identifier);

  }

  public Lock getLock(String identifier) {

    Lock lock = null;

    try {

        lock = getInstance().getHazelcastInstance().getLock(identifier);

    } catch (RuntimeException e) {

        logMetacat.info("Couldn't get a lock for identifier " + 

            identifier + " !!");

    }

    return lock;

  }

  /**

   * Get the DataONE hazelcast node map

   * @return nodes - the hazelcast map of nodes

   */

//  public IMap<NodeReference, Node> getNodesMap() {

//	  return nodes;

//  }

  /**

   * Indicate whether or not this service is refreshable.

   *

   * @return refreshable - the boolean refreshable status

   */

  public boolean refreshable() {

    // TODO: Determine the consequences of restarting the Hazelcast instance

    // Set this to true if it's okay to drop from the cluster, lose the maps,

    // and start back up again

    return false;

  }

  /**

   * Stop the HazelcastService. When stopped, the service will no longer

   * respond to requests.

   */

  public void stop() throws ServiceException {

    Hazelcast.getLifecycleService().shutdown();

  }

  /**

   * Listen for new Hazelcast member events

   */

  @Override

  public void instanceCreated(InstanceEvent event) {

    logMetacat.info("New Hazelcast instance created: " +

      event.getInstance().getId() + ", " +

      event.getInstance().getInstanceType());

  }

  @Override

  public void instanceDestroyed(InstanceEvent event) {

    logMetacat.info("Hazelcast instance removed: " +

        event.getInstance().getId() + ", " +

        event.getInstance().getInstanceType());

  }

  public HazelcastInstance getHazelcastInstance() {

      return this.hzInstance;

  }

  /**

   * Refresh the Hazelcast service by restarting it

   */

  @Override

  protected void doRefresh() throws ServiceException {

    // TODO: verify that the correct config file is still used

    Hazelcast.getLifecycleService().restart();

  }

  /**

	 * Implement the EntryListener interface for Hazelcast, reponding to entry

	 * added events in the hzSystemMetadata map. Evaluate the entry and create

	 * CNReplicationTasks as appropriate (for DATA, METADATA, RESOURCE)

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	@Override

	public void entryAdded(EntryEvent<Identifier, SystemMetadata> event) {

		// handle as update - that method will create if necessary

		entryUpdated(event);

	}

	/**

	 * Implement the EntryListener interface for Hazelcast, reponding to entry

	 * evicted events in the hzSystemMetadata map.  Evaluate the entry and create

	 * CNReplicationTasks as appropriate (for DATA, METADATA, RESOURCE)

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	@Override

	public void entryEvicted(EntryEvent<Identifier, SystemMetadata> event) {

	    // ensure identifiers are listed in the hzIdentifiers set

      if ( !identifiers.contains(event.getKey()) ) {

          identifiers.add(event.getKey());

      }

	}

	/**

	 * Implement the EntryListener interface for Hazelcast, reponding to entry

	 * removed events in the hzSystemMetadata map.  Evaluate the entry and create

	 * CNReplicationTasks as appropriate (for DATA, METADATA, RESOURCE)

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	@Override

	public void entryRemoved(EntryEvent<Identifier, SystemMetadata> event) {

		// we typically don't remove objects in Metacat, but can remove System Metadata

		IdentifierManager.getInstance().deleteSystemMetadata(event.getValue().getIdentifier().getValue());

    // keep the hzIdentifiers set in sync with the systemmetadata table

    if ( identifiers.contains(event.getKey()) ) {

        identifiers.remove(event.getKey());

    }

	}

	/**

	 * Implement the EntryListener interface for Hazelcast, reponding to entry

	 * updated events in the hzSystemMetadata map.  Evaluate the entry and create

	 * CNReplicationTasks as appropriate (for DATA, METADATA, RESOURCE)

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	@Override

	public void entryUpdated(EntryEvent<Identifier, SystemMetadata> event) {

			logMetacat.debug("Entry added/updated to System Metadata map: " + event.getKey().getValue());

			PartitionService partitionService = Hazelcast.getPartitionService();

			Partition partition = partitionService.getPartition(event.getKey());

			Member ownerMember = partition.getOwner();

			if (!ownerMember.localMember()) {

				// need to pull the entry into the local store

				saveLocally(event.getValue());

			}

			// TODO evaluate the type of system metadata change, decide if it

			// warrants a replication event, what type (DATA, METADATA, RESOURCE),

			// iteratively lock the PID, create and submit the tasks, and expect a

			// result back. Deal with exceptions.

			SystemMetadata sysmeta = event.getValue();

			if (sysmeta != null) {

				boolean isMetadata = D1NodeService.isScienceMetadata(event.getValue());

				// TODO: do we need to do anything explicit here?

			}

	     // ensure identifiers are listed in the hzIdentifiers set

      if ( !identifiers.contains(event.getKey()) ) {

          identifiers.add(event.getKey());

      }

	}

	/**

	 * Save SystemMetadata to local store if needed

	 * @param sm

	 */

	private void saveLocally(SystemMetadata sm) {

		logMetacat.debug("Saving entry locally: " + sm.getIdentifier().getValue());

		try {

			if (!IdentifierManager.getInstance().systemMetadataExists(sm.getIdentifier().getValue())) {

				IdentifierManager.getInstance().createSystemMetadata(sm);

			} else {

				IdentifierManager.getInstance().updateSystemMetadata(sm);

			}

		} catch (McdbDocNotFoundException e) {

			logMetacat.error(

					"Could not save System Metadata to local store.", e);

		}

	}

	public void resynch() throws Exception {

		// get the CN that is online

		// TODO: do we even need to use a specific CN?

		// All the System Metadata records should be available via the shared map

//		NodeList allNodes = CNodeService.getInstance().listNodes();

//		Node onlineCN = null;

//		for (Node node: allNodes.getNodeList()) {

//			if (node.getType().equals(NodeType.CN)) {

//				if (node.getState().equals(NodeState.UP)) {

//					onlineCN = node;

//					break;

//				}

//			}

//		}

		// get the list of items that have changed since X

		Date since = IdentifierManager.getInstance().getLastModifiedDate();

		EntryObject e = new PredicateBuilder().getEntryObject();

		Predicate predicate = e.get(SINCE_PROPERTY).greaterEqual(since);

		Collection<SystemMetadata> updatedSystemMetadata = getSystemMetadataMap().values(predicate);

		for (SystemMetadata sm: updatedSystemMetadata) {

			saveLocally(sm);

		}

	}

}