Metacat

package edu.ucsb.nceas.metacat.dataone.hazelcast;

import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;

import java.io.File;

import java.util.Map;

import java.util.concurrent.Callable;

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

import org.junit.After;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.rules.ErrorCollector;

import com.hazelcast.core.Hazelcast;

import com.hazelcast.core.HazelcastInstance;

import edu.ucsb.nceas.MCTestCase;

public class HzObjectPathMapTest extends MCTestCase {

	public final static String CONFIG_PATH = "/Users/rnahf/" +

//			"projects/" +

			"software/workspace" + 

			"nceas/metacat/test/edu/ucsb/nceas/metacat/dataone/hazelcast";

	/**

	 * Need to use the error collector to handle JUnit assertions

	 * and keep going.  This is because setting up multiple tests of

	 * Hazelcast is not straightforward.

	 * The check methods in this class use this errorCollector

	 * the check methods 

	 */

	@Rule 

    public ErrorCollector errorCollector = new ErrorCollector();

    protected void checkEquals(final String message, final String s1, final String s2)

    {

 //   	System.out.println("assertion: " + message);

    	errorCollector.checkSucceeds(new Callable<Object>() 

        {

            public Object call() throws Exception 

            {

                assertThat(message, s1, is(s2));

                return null;

            }

        });

    }

    /**

	 * performs the equivalent of the junit assertTrue method

	 * using the errorCollector to record the error and keep going

	 * 

	 * @param message

	 * @param s1

	 * @param s2

	 */

    protected void checkTrue(final String message, final boolean b)

    {

//        System.out.println("assertion: " + message);

    	errorCollector.checkSucceeds(new Callable<Object>() 

        {

            public Object call() throws Exception 

            {

            	assertThat(message, true, is(b));

            	return null;

            }

        });

    }

	@After

    public void cleanup() throws Exception {

        Hazelcast.shutdownAll(); 

    }

	@Test

	public void testBehavior() {

		/**

		 * set up the two hazelcast instances (separate configurations)

		 * mapProvider is configured with the ObjectPathMap (MapLoader)

		 * mapUser is configured with a default config file (no MapLoader implementation)

		 */

		File configPath = new File(CONFIG_PATH + "hzObjectPathMap.provider.test.properties.xml");

		checkTrue("config file should exist", configPath.canRead());

		System.getProperties().setProperty("hazelcast.config", configPath.getAbsolutePath());

		HazelcastInstance mapProvider = Hazelcast.newHazelcastInstance(null);

		// setup and start the non-maploader member (d1_indexer)

		configPath = new File(CONFIG_PATH + "hzObjectPathMap.user.test.properties.xml");

		checkTrue("config file should exist", configPath.canRead());

		System.getProperties().setProperty("hazelcast.config", configPath.getAbsolutePath());	

		HazelcastInstance mapUser = Hazelcast.newHazelcastInstance(null);

		// try to read from uninstantiated map

		Map<Identifier,String> userMap = mapUser.getMap("hzObjectPath");		

		checkTrue("userMap should be empty at first", userMap.size() == 0);

		Map<Identifier,String> providerMap = mapProvider.getMap("hzObjectPath");

		checkTrue("providerMap should have keys", providerMap.size() > 0);

		checkTrue("userMap should have keys now", userMap.size() > 0);

		System.out.println("test Getting Preloaded Keys Via the UserMap"); 

		String pathValue = userMap.get(createIdentifier("testID.26"));

		System.out.println("pathValue: " + pathValue);

		checkEquals("userMap should contain a value for this", 

				"/path/testID.26", pathValue);

		System.out.println("test Getting Unloaded Keys Via the UserMap");

		pathValue = userMap.get(createIdentifier("anNewKey"));

		System.out.println("pathValue: " + pathValue);

		checkEquals("userMap should contain a value for this", 

				"/path/anNewKey", pathValue);

		System.out.println("test Entry Not Added When Key Not In Datastore");

		pathValue = userMap.get(createIdentifier("NO_CREATE_identifier"));

		System.out.println("pathValue: " + pathValue);

		checkEquals("providerInstance should return null if not found", null, pathValue);

	}

//		

//		System.out.println(serverMap.get(createIdentifier("testID.35")));

//		System.out.println(serverMap.get(createIdentifier("aNewIdentifier")));

//		

////		System.getProperties().setProperty("hazelcast.hzObjectPathRole","consumer");

//	

//		System.out.println("client Instance");

//		System.out.println("1 " + clientMap.get(createIdentifier("testID.35")));

//		System.out.println("2 " + clientMap.get(createIdentifier("aNewIdentifier")));

//		

//		String lookupMyPathPlease = "foo";

//		String pathValue = (String) clientMap.get(createIdentifier(lookupMyPathPlease));

//		System.out.println("remote retrieval of pathValue: " + pathValue);

//		

//		pathValue = (String) serverMap.get(createIdentifier(lookupMyPathPlease));		

//		System.out.println("server retrieval of pathValue: " + pathValue);

//			

//		pathValue = (String) clientMap.get(createIdentifier(lookupMyPathPlease));		

//		System.out.println("remote retrieval of pathValue again: " + pathValue);

//		

//		//assertEquals("/path/" + lookupMyPathPlease, pathValue);

//	}	

	private Identifier createIdentifier(String idValue) {

		Identifier id = new Identifier();

		id.setValue(idValue);

		return id;

	}

}

<?xml version="1.0" encoding="UTF-8"?>

<hazelcast xsi:schemaLocation="http://www.hazelcast.com/schema/config hazelcast-basic.xsd"

           xmlns="http://www.hazelcast.com/schema/config"

           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <group>

        <name>dev</name>

        <password>dev-pass</password>

    </group>

    <network>

        <port auto-increment="true">5701</port>

        <join>

            <multicast enabled="true">

                <multicast-group>224.2.2.3</multicast-group>

                <multicast-port>54327</multicast-port>

            </multicast>

            <tcp-ip enabled="false">

                <interface>127.0.0.1</interface>

            </tcp-ip>

        </join>

        <interfaces enabled="false">

            <interface>10.10.1.*</interface>

        </interfaces>

        <symmetric-encryption enabled="false">

            <!--

               encryption algorithm such as

               DES/ECB/PKCS5Padding,

               PBEWithMD5AndDES,

               AES/CBC/PKCS5Padding,

               Blowfish,

               DESede

            -->

            <algorithm>PBEWithMD5AndDES</algorithm>

            <!-- salt value to use when generating the secret key -->

            <salt>thesalt</salt>

            <!-- pass phrase to use when generating the secret key -->

            <password>thepass</password>

            <!-- iteration count to use when generating the secret key -->

            <iteration-count>19</iteration-count>

        </symmetric-encryption>

        <asymmetric-encryption enabled="false">

            <!-- encryption algorithm -->

            <algorithm>RSA/NONE/PKCS1PADDING</algorithm>

            <!-- private key password -->

            <keyPassword>thekeypass</keyPassword>

            <!-- private key alias -->

            <keyAlias>local</keyAlias>

            <!-- key store type -->

            <storeType>JKS</storeType>

            <!-- key store password -->

            <storePassword>thestorepass</storePassword>

            <!-- path to the key store -->

            <storePath>keystore</storePath>

        </asymmetric-encryption>

    </network>

    <executor-service>

        <core-pool-size>16</core-pool-size>

        <max-pool-size>64</max-pool-size>

        <keep-alive-seconds>60</keep-alive-seconds>

    </executor-service>

    <queue name="default">

        <!--

            Maximum size of the queue. When a JVM's local queue size reaches the maximum,

            all put/offer operations will get blocked until the queue size

            of the JVM goes down below the maximum.

            Any integer between 0 and Integer.MAX_VALUE. 0 means

            Integer.MAX_VALUE. Default is 0.

        -->

        <max-size-per-jvm>0</max-size-per-jvm>

        <!--

            Name of the map configuration that will be used for the backing distributed

            map for this queue.

        -->

        <backing-map-ref>default</backing-map-ref>

    </queue>

    <map name="default">

        <!--

            Number of backups. If 1 is set as the backup-count for example,

            then all entries of the map will be copied to another JVM for

            fail-safety. Valid numbers are 0 (no backup), 1, 2, 3.

        -->

        <backup-count>1</backup-count>

        <!--

            Valid values are:

            NONE (no eviction),

            LRU (Least Recently Used),

            LFU (Least Frequently Used).

            NONE is the default.

        -->

        <eviction-policy>NONE</eviction-policy>

        <!--

            Maximum size of the map. When max size is reached,

            map is evicted based on the policy defined.

            Any integer between 0 and Integer.MAX_VALUE. 0 means

            Integer.MAX_VALUE. Default is 0.

        -->

        <max-size policy="cluster_wide_map_size">0</max-size>

        <!--

            When max. size is reached, specified percentage of

            the map will be evicted. Any integer between 0 and 100.

            If 25 is set for example, 25% of the entries will

            get evicted.

        -->

        <eviction-percentage>25</eviction-percentage>

        <!--

            While recovering from split-brain (network partitioning),

            map entries in the small cluster will merge into the bigger cluster

            based on the policy set here. When an entry merge into the

            cluster, there might an existing entry with the same key already.

            Values of these entries might be different for that same key.

            Which value should be set for the key? Conflict is resolved by

            the policy set here. Default policy is hz.ADD_NEW_ENTRY

            There are built-in merge policies such as

            hz.NO_MERGE      ; no entry will merge.

            hz.ADD_NEW_ENTRY ; entry will be added if the merging entry's key

                               doesn't exist in the cluster.

            hz.HIGHER_HITS   ; entry with the higher hits wins.

            hz.LATEST_UPDATE ; entry with the latest update wins.

        -->

        <merge-policy>hz.ADD_NEW_ENTRY</merge-policy>

    </map>

    <map name="hzObjectPath">

        ...

        <map-store enabled="true">

            <!--

               Name of the class implementing MapLoader and/or MapStore. 

               The class should implement at least of these interfaces and

               contain no-argument constructor. Note that the inner classes are not supported.

            -->

            <class-name>edu.ucsb.nceas.metacat.dataone.hazelcast.MockObjectPathMap</class-name>

            <!--

               Number of seconds to delay to call the MapStore.store(key, value).

               If the value is zero then it is write-through so MapStore.store(key, value)

               will be called as soon as the entry is updated.

               Otherwise it is write-behind so updates will be stored after write-delay-seconds

               value by calling Hazelcast.storeAll(map). Default value is 0.

            -->

            <write-delay-seconds>0</write-delay-seconds>

        </map-store>

    </map>

    <!-- Add your own map merge policy implementations here:     

    	<merge-policies>

           	<map-merge-policy name="MY_MERGE_POLICY">

            	<class-name>com.acme.MyOwnMergePolicy</class-name>

        	</map-merge-policy>

    	</merge-policies>

    -->

</hazelcast>

<?xml version="1.0" encoding="UTF-8"?>

<hazelcast xsi:schemaLocation="http://www.hazelcast.com/schema/config hazelcast-basic.xsd"

           xmlns="http://www.hazelcast.com/schema/config"

           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <group>

        <name>dev</name>

        <password>dev-pass</password>

    </group>

    <network>

        <port auto-increment="true">5701</port>

        <join>

            <multicast enabled="true">

                <multicast-group>224.2.2.3</multicast-group>

                <multicast-port>54327</multicast-port>

            </multicast>

            <tcp-ip enabled="false">

                <interface>127.0.0.1</interface>

            </tcp-ip>

        </join>

        <interfaces enabled="false">

            <interface>10.10.1.*</interface>

        </interfaces>

        <symmetric-encryption enabled="false">

            <!--

               encryption algorithm such as

               DES/ECB/PKCS5Padding,

               PBEWithMD5AndDES,

               AES/CBC/PKCS5Padding,

               Blowfish,

               DESede

            -->

            <algorithm>PBEWithMD5AndDES</algorithm>

            <!-- salt value to use when generating the secret key -->

            <salt>thesalt</salt>

            <!-- pass phrase to use when generating the secret key -->

            <password>thepass</password>

            <!-- iteration count to use when generating the secret key -->

            <iteration-count>19</iteration-count>

        </symmetric-encryption>

        <asymmetric-encryption enabled="false">

            <!-- encryption algorithm -->

            <algorithm>RSA/NONE/PKCS1PADDING</algorithm>

            <!-- private key password -->

            <keyPassword>thekeypass</keyPassword>

            <!-- private key alias -->

            <keyAlias>local</keyAlias>

            <!-- key store type -->

            <storeType>JKS</storeType>

            <!-- key store password -->

            <storePassword>thestorepass</storePassword>

            <!-- path to the key store -->

            <storePath>keystore</storePath>

        </asymmetric-encryption>

    </network>

    <executor-service>

        <core-pool-size>16</core-pool-size>

        <max-pool-size>64</max-pool-size>

        <keep-alive-seconds>60</keep-alive-seconds>

    </executor-service>

    <queue name="default">

        <!--

            Maximum size of the queue. When a JVM's local queue size reaches the maximum,

            all put/offer operations will get blocked until the queue size

            of the JVM goes down below the maximum.

            Any integer between 0 and Integer.MAX_VALUE. 0 means

            Integer.MAX_VALUE. Default is 0.

        -->

        <max-size-per-jvm>0</max-size-per-jvm>

        <!--

            Name of the map configuration that will be used for the backing distributed

            map for this queue.

        -->

        <backing-map-ref>default</backing-map-ref>

    </queue>

    <map name="default">

        <!--

            Number of backups. If 1 is set as the backup-count for example,

            then all entries of the map will be copied to another JVM for

            fail-safety. Valid numbers are 0 (no backup), 1, 2, 3.

        -->

        <backup-count>1</backup-count>

        <!--

            Valid values are:

            NONE (no eviction),

            LRU (Least Recently Used),

            LFU (Least Frequently Used).

            NONE is the default.

        -->

        <eviction-policy>NONE</eviction-policy>

        <!--

            Maximum size of the map. When max size is reached,

            map is evicted based on the policy defined.

            Any integer between 0 and Integer.MAX_VALUE. 0 means

            Integer.MAX_VALUE. Default is 0.

        -->

        <max-size policy="cluster_wide_map_size">0</max-size>

        <!--

            When max. size is reached, specified percentage of

            the map will be evicted. Any integer between 0 and 100.

            If 25 is set for example, 25% of the entries will

            get evicted.

        -->

        <eviction-percentage>25</eviction-percentage>

        <!--

            While recovering from split-brain (network partitioning),

            map entries in the small cluster will merge into the bigger cluster

            based on the policy set here. When an entry merge into the

            cluster, there might an existing entry with the same key already.

            Values of these entries might be different for that same key.

            Which value should be set for the key? Conflict is resolved by

            the policy set here. Default policy is hz.ADD_NEW_ENTRY

            There are built-in merge policies such as

            hz.NO_MERGE      ; no entry will merge.

            hz.ADD_NEW_ENTRY ; entry will be added if the merging entry's key

                               doesn't exist in the cluster.

            hz.HIGHER_HITS   ; entry with the higher hits wins.

            hz.LATEST_UPDATE ; entry with the latest update wins.

        -->

        <merge-policy>hz.ADD_NEW_ENTRY</merge-policy>

    </map>

    <!-- Add your own map merge policy implementations here:     

    	<merge-policies>

           	<map-merge-policy name="MY_MERGE_POLICY">

            	<class-name>com.acme.MyOwnMergePolicy</class-name>

        	</map-merge-policy>

    	</merge-policies>

    -->

</hazelcast>

package edu.ucsb.nceas.metacat.dataone.hazelcast;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;

import java.util.Set;

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

import com.hazelcast.core.MapLoader;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

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

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * MapLoader implementation for a hazelcast hzObjectPath.  This class is called

 * when the ObjectPathMap needs to refresh against the persistent data-store.

 * The use case for this class is to communicate the filepath between JVMs on

 * the same machine, specifically between the metacat instance and the d1_indexer.

 * 

 * d1_indexer will get Identifiers from elsewhere, but use this class to get

 * the paths to their associated files.  The getAllKeys() method can (and should)

 * return null in a live setting.  For unit testing, it may be useful to use

 * it to get some 

 * 

 * @author rnahf

 *

 */

public class MockObjectPathMap implements MapLoader<Identifier, String> {

	private static IdentifierManager im;

	private static String dataPath;

	private static String metadataPath;

	/**

	 * creates an ObjectPathMap

	 */

	public MockObjectPathMap() {

//		try {

//			PropertyService ps = PropertyService.getInstance();

//			dataPath = PropertyService.getProperty("application.datafilepath");

//			metadataPath = PropertyService.getProperty("application.documentfilepath");

//		} catch (PropertyNotFoundException e) {

//			// TODO Auto-generated catch block

//			e.printStackTrace();

//		} catch (ServiceException e) {

//			// TODO Auto-generated catch block

//			e.printStackTrace();

//		}

		dataPath = "/data/";

		metadataPath = "/metadata/";

		im = IdentifierManager.getInstance();

	}

	/*

	 * Metadata is stored in a different place on the filesystem than

	 * the data.  The doctype value for metadata can vary, but for data

	 * is always 'BIN', so using a simple if-then-else to separate

	 */

	private String pathToDocid(String localid) throws McdbDocNotFoundException  {

		return "/some/path/" + localid; 

//		Hashtable<String, Object> ht = im.getDocumentInfo(localid);

//		if (ht.get("doctype").equals("BIN")) {

//			return dataPath + FileUtil.getFS() + localid;

//		} else {

//			return metadataPath + FileUtil.getFS() + localid;

//		}		

	}

	/**

	 *  Implementation of hazelcast MapLoader interface method.

	 *  For the provided Identifier (as key), returns the path to the

	 *  document on the local filesystem.  Returns null if it can't 

	 *  create the path. 

	 */

	@Override

	public String load(Identifier key) 

	{

		String docid = null;

		String path = null;

		//			try {

		//				docid = im.getLocalId(key.getValue());

		//				path = pathToDocid(docid);			

		//			} catch (McdbDocNotFoundException e) {

		//				// TODO Auto-generated catch block

		//				e.printStackTrace();

		//				return null;

		//			}

		if (key.getValue().startsWith("NO_CREATE")) {

			return null;

		}

		path = "/path/" + key.getValue();

		return path;

	}

	/**

	 *  Implementation of hazelcast MapLoader interface method.  This method loads

	 *  mappings for all Identifiers in the parameters.  Any Identifier not found

	 *  is not included in the resulting map.

	 */

	@Override

	public Map<Identifier, String> loadAll(Collection<Identifier> identifiers) {

		Hashtable<Identifier,String> map = new Hashtable<Identifier,String>();

		for (Identifier id : identifiers) {

			map.put(id, "/path/" + id.getValue());

			//				try {

			//					String docid = im.getLocalId(id.getValue());

			//					map.put(id, pathToDocid(docid));

			//

			//				} catch (McdbDocNotFoundException e) {

			//					// TODO should the map load an empty path instead of

			//					// leaving out the entire entry?

			//					e.printStackTrace();

			//				}

		}

		return map;

	}

	/**

	 * Return the full set of guids in the local metacat repository as

	 * dataone Identifiers.

	 * 

	 * (Hazelcast allows avoiding pre-loading by returning NULL, so consider

	 * re-implementing if that serves the purpose of this class better)

	 */

	@Override

	public Set<Identifier> loadAllKeys() 

	{

		//		List<String> guids = im.getAllGUIDs();

		//		

		Set<Identifier> set = Collections.synchronizedSet(new HashSet<Identifier>());

		//		for (String guid : guids) {

		//			Identifier id = new Identifier();

		//			id.setValue(guid);

		//			set.add(id);

		//		}

		for (int i=1; i< 100; i++) {

			Identifier id = new Identifier();

			id.setValue("testID." + i);

			set.add(id);

		}

		return set;

	}

}

 * when the IMap get methods needs to refresh against the persistent data-store.

 * the paths to their associated files.  The getAllKeys() method will

 * return null in a live setting, to avoid possibly expensive preloading

		try {

			PropertyService ps = PropertyService.getInstance();

			dataPath = PropertyService.getProperty("application.datafilepath");

			metadataPath = PropertyService.getProperty("application.documentfilepath");

		} catch (PropertyNotFoundException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (ServiceException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	private String pathToDocid(String localid) throws McdbDocNotFoundException  

	{	

		Hashtable<String, Object> ht = im.getDocumentInfo(localid);

		if (ht.get("doctype").equals("BIN")) {

			return dataPath + FileUtil.getFS() + localid;

		} else {

			return metadataPath + FileUtil.getFS() + localid;

		}		

		String docid = null;

		String path = null;

		try {

			docid = im.getLocalId(key.getValue());

			path = pathToDocid(docid);			

		} catch (McdbDocNotFoundException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		return path;

		Hashtable<Identifier,String> map = new Hashtable<Identifier,String>();

		for (Identifier id : identifiers) {

			try {

				String docid = im.getLocalId(id.getValue());

				map.put(id, pathToDocid(docid));

			} catch (McdbDocNotFoundException e) {

				// TODO should the map load an empty path instead of

				// leaving out the entire entry?

				e.printStackTrace();

		return map;

	 * (Hazelcast allows avoiding pre-loading by returning NULL, so will

	 * do this to avoid pre-loading a very long list unnecessarily)

	public Set<Identifier> loadAllKeys() 

	{

		return null;

//		List<String> guids = im.getAllGUIDs();

//

//		Set<Identifier> set = Collections.synchronizedSet(new HashSet<Identifier>());

//		for (String guid : guids) {

//			Identifier id = new Identifier();

//			id.setValue(guid);

//			set.add(id);

//		}

//		return set;