/**
* The contents of this file are subject to the license and copyright
* detailed in the LICENSE and NOTICE files at the root of the source
* tree and available online at
*
* http://www.dspace.org/license/
*/
package org.dspace.handle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import net.handle.hdllib.Encoder;
import net.handle.hdllib.HandleException;
import net.handle.hdllib.HandleStorage;
import net.handle.hdllib.HandleValue;
import net.handle.hdllib.ScanCallback;
import net.handle.hdllib.Util;
import net.handle.util.StreamTable;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import java.util.Iterator;
/**
* Extension to the CNRI Handle Server that translates requests to resolve
* handles into remote calls to the mini-DSpace Handle resolver JSON API. This
* only provides some of the functionality (namely, the resolving of handles to
* URLs) of the CNRI HandleStorage interface.
*
* <p>
* This class is intended to be embedded in the CNRI Handle Server. It conforms
* to the HandleStorage interface that was delivered with Handle Server version
* 6.2.0.
* </p>
*
* @author Andrea Bollini
*/
public class MultiRemoteDSpaceRepositoryHandlePlugin implements HandleStorage
{
/**
* Name of configuration file. This can be overwritten by setting a path
* to the configuration file to use in the system property
* <code>dspace.handle.plugin.configuration</code>.
*/
private static String CONFIG_FILE_NAME = "handle-dspace-plugin.cfg";
/**
* Every Property starting with this key will be used as DSpace endpoint
* while resolving handles, f.e. http://localhost:8080/xmlui/handleresolver.
*/
private static String PROPERTY_KEY = "dspace.handle.endpoint";
/** log4j category */
private static Logger log = Logger
.getLogger(MultiRemoteDSpaceRepositoryHandlePlugin.class);
// maps prefixes to URLs from DSpace instances
private Map<String, String> prefixes;
/**
* Constructor
*/
public MultiRemoteDSpaceRepositoryHandlePlugin()
{
}
// //////////////////////////////////////
// Non-Resolving methods -- unimplemented
// //////////////////////////////////////
/**
* HandleStorage interface method - not implemented.
*/
public void init(StreamTable st) throws Exception
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called init");
}
// initalize our prefix map
this.prefixes = new HashMap<String, String>();
// try to find our configuration
Properties properties = loadProperties(CONFIG_FILE_NAME);
// find urls of all configured dspace instances
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String propertyName = (String) e.nextElement();
if (propertyName.startsWith(this.PROPERTY_KEY))
{
// load the prefixes of this instance
loadPrefixes(properties.getProperty(propertyName));
}
}
// did we found any prefixes?
if (this.prefixes.isEmpty())
{
throw new HandleException(HandleException.INTERNAL_ERROR,
"Unable to find configuration or to reach any DSpace instance.");
}
if (log.isInfoEnabled())
{
for (Iterator<String> it = this.prefixes.keySet().iterator(); it.hasNext() ;)
{
String prefix = it.next();
log.info("Loaded Prefix " + prefix + " from " + this.prefixes.get(prefix));
}
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void setHaveNA(byte[] theHandle, boolean haveit)
throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called setHaveNA (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void createHandle(byte[] theHandle, HandleValue[] values)
throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called createHandle (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public boolean deleteHandle(byte[] theHandle) throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called deleteHandle (not implemented)");
}
return false;
}
/**
* HandleStorage interface method - not implemented.
*/
public void updateValue(byte[] theHandle, HandleValue[] values)
throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called updateValue (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void deleteAllRecords() throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called deleteAllRecords (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void checkpointDatabase() throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called checkpointDatabase (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void shutdown()
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called shutdown (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void scanHandles(ScanCallback callback) throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called scanHandles (not implemented)");
}
}
/**
* HandleStorage interface method - not implemented.
*/
public void scanNAs(ScanCallback callback) throws HandleException
{
// Not implemented
if (log.isInfoEnabled())
{
log.info("Called scanNAs (not implemented)");
}
}
// //////////////////////////////////////
// Resolving methods
// //////////////////////////////////////
/**
* Return the raw values for this handle. This implementation returns a
* single URL value.
*
* @param theHandle
* byte array representation of handle
* @param indexList
* ignored
* @param typeList
* ignored
* @return A byte array with the raw data for this handle. Currently, this
* consists of a single URL value.
* @exception HandleException
* If an error occurs while calling the Handle API.
*/
public byte[][] getRawHandleValues(byte[] theHandle, int[] indexList,
byte[][] typeList) throws HandleException
{
if (log.isInfoEnabled())
{
log.info("Called getRawHandleValues");
}
if (theHandle == null)
{
throw new HandleException(HandleException.INTERNAL_ERROR);
}
String handle = Util.decodeString(theHandle);
String url = getRemoteDSpaceURL(handle);
HandleValue value = new HandleValue();
value.setIndex(100);
value.setType(Util.encodeString("URL"));
value.setData(Util.encodeString(url));
value.setTTLType((byte) 0);
value.setTTL(100);
value.setTimestamp(100);
value.setReferences(null);
value.setAdminCanRead(true);
value.setAdminCanWrite(false);
value.setAnyoneCanRead(true);
value.setAnyoneCanWrite(false);
List<HandleValue> values = new LinkedList<HandleValue>();
values.add(value);
byte[][] rawValues = new byte[values.size()][];
for (int i = 0; i < values.size(); i++)
{
HandleValue hvalue = values.get(i);
rawValues[i] = new byte[Encoder.calcStorageSize(hvalue)];
Encoder.encodeHandleValue(rawValues[i], 0, hvalue);
}
return rawValues;
}
private String getRemoteDSpaceURL(String handle) throws HandleException
{
if (log.isInfoEnabled())
{
log.info("Called getRemoteDSpaceURL("+handle+").");
}
InputStreamReader jsonStreamReader = null;
String url = null;
try
{
String prefix = handle.split("/")[0];
String endpoint = this.prefixes.get(prefix);
if (endpoint == null)
{
if (log.isDebugEnabled())
{
log.debug("Cannot find endpoint for prefix " + prefix + ", throw HANDLE_DOES_NOT_EXIST.");
}
throw new HandleException(HandleException.HANDLE_DOES_NOT_EXIST);
}
String jsonurl = endpoint + "/resolve/" + handle;
jsonStreamReader = new InputStreamReader(
new URL(jsonurl).openStream(), "UTF-8");
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(jsonStreamReader);
if (jsonElement == null || jsonElement.isJsonNull()
|| jsonElement.getAsJsonArray().size() == 0
|| jsonElement.getAsJsonArray().get(0).isJsonNull())
{
if (log.isDebugEnabled())
{
log.debug("Throw HandleException: HANDLE_DOES_NOT_EXIST.");
}
throw new HandleException(HandleException.HANDLE_DOES_NOT_EXIST);
}
url = jsonElement.getAsJsonArray().get(0).getAsString();
}
catch (Exception e)
{
if (log.isDebugEnabled())
{
log.debug("Exception in getRawHandleValues", e);
}
// Stack loss as exception does not support cause
throw new HandleException(HandleException.INTERNAL_ERROR);
}
finally
{
if (jsonStreamReader != null)
{
try
{
jsonStreamReader.close();
}
catch (IOException e)
{
log.error(e.getMessage(), e);
}
}
}
if (log.isDebugEnabled())
{
log.debug(("getRemoteDspaceURL returns " + url));
}
return url;
}
/**
* Return true if we have this handle in storage.
*
* @param theHandle
* byte array representation of handle
* @return True if we have this handle in storage
* @exception HandleException
* If an error occurs while calling the Handle API.
*/
public boolean haveNA(byte[] theHandle) throws HandleException
{
if (log.isInfoEnabled())
{
log.info("Called haveNA");
}
/*
* Naming authority Handles are in the form: 0.NA/1721.1234
*
* 0.NA is basically the naming authority for naming authorities. For
* this simple implementation, we will just check if the requestes
* prefix is one that DSpace returns when we call
* handleresolver/listprefixes.
*/
// Which authority does the request pertain to? Remove the heading "0.NA/".
String received = Util.decodeString(theHandle).substring("0.NA/".length());
return this.prefixes.containsKey(received);
}
/**
* Return all handles in local storage which start with the naming authority
* handle.
*
* @param theNAHandle
* byte array representation of naming authority handle
* @return All handles in local storage which start with the naming
* authority handle.
* @exception HandleException
* If an error occurs while calling the Handle API.
*/
public Enumeration getHandlesForNA(byte[] theNAHandle)
throws HandleException
{
String naHandle = Util.decodeString(theNAHandle);
if (log.isInfoEnabled())
{
log.info("Called getHandlesForNA for NA " + naHandle);
}
List<String> handles = getRemoteDSpaceHandles(naHandle);
List<byte[]> results = new LinkedList<byte[]>();
for (String handle : handles)
{
// Transforms to byte array
results.add(Util.encodeString(handle));
}
return Collections.enumeration(results);
}
private List<String> getRemoteDSpaceHandles(String naHandle)
throws HandleException
{
List<String> handles = new ArrayList<String>();
String endpoint = this.prefixes.get(naHandle);
if (null == endpoint)
{
// We don't know anything about this prefix, return an empty list.
return handles;
}
InputStreamReader jsonStreamReader = null;
try
{
String jsonurl = endpoint + "/listhandles/" + naHandle;
jsonStreamReader = new InputStreamReader(
new URL(jsonurl).openStream(), "UTF-8");
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(jsonStreamReader);
if (jsonElement != null && jsonElement.getAsJsonArray().size() != 0)
{
for (int i = 0; i < jsonElement.getAsJsonArray().size(); i++)
{
handles.add(jsonElement.getAsJsonArray().get(i)
.getAsString());
}
}
}
catch (Exception e)
{
if (log.isDebugEnabled())
{
log.debug("Exception in getHandlesForNA", e);
}
// Stack loss as exception does not support cause
throw new HandleException(HandleException.INTERNAL_ERROR);
}
finally
{
if (jsonStreamReader != null)
{
try
{
jsonStreamReader.close();
}
catch (IOException e)
{
log.error(e.getMessage(), e);
}
}
}
return handles;
}
private Properties loadProperties(String filename) throws IOException
{
InputStream is = findConfigFile(filename);
Properties props = new Properties();
InputStreamReader ir = null;
// load the configuration
try {
ir = new InputStreamReader(is, "UTF-8");
props.load(ir);
} catch (UnsupportedEncodingException ex) {
if (log.isInfoEnabled())
{
log.info("Caught an UnsupportedEncodingException while loading configuration: " + ex.getMessage());
}
throw new RuntimeException(ex);
}
catch (IOException ex)
{
if (log.isInfoEnabled())
{
log.info("Caught an IOException while loading configuration: " + ex.getMessage());
}
throw ex;
}
finally
{
if (ir != null)
{
try
{
ir.close();
}
catch (IOException ex)
{
// nothing to do.
}
}
if (is != null)
{
try
{
is.close();
}
catch (IOException ex)
{
// nothing to do.
}
}
}
return props;
}
private InputStream findConfigFile(String filename)
{
InputStream is = null;
// try to load config file as defined in system property:
try
{
String configProperty = System.getProperty("dspace.handle.plugin.configuration");
if (null != configProperty)
{
is = new FileInputStream(configProperty);
}
}
catch (SecurityException se)
{
// A security manager may stop us from accessing the system properties.
// This isn't really a fatal error though, so catch and ignore
log.warn("Unable to access system properties, ignoring.", se);
}
catch (FileNotFoundException fne)
{
log.warn("Unable to find config file as defined by system property: "
+ fne.getMessage());
}
if (null == is)
{
// try some default locations
URL url = MultiRemoteDSpaceRepositoryHandlePlugin.class.getResource(
"/" + filename);
if (null == url)
{
if (log.isInfoEnabled())
{
log.info("Cannot find configuration by using getResource().");
}
} else {
try
{
is = new FileInputStream(url.getPath());
log.warn("Falling back to default locations, "
+ "found configuration at: " + url.getPath());
}
catch (FileNotFoundException e)
{
if (log.isInfoEnabled())
{
// didn't found fallback config, nothing to do about it.
log.info("Unable to open fallback configuration: " + e.getMessage());
}
}
}
}
if (null == is)
{
// try to find configuration in the current working directory
// where the user started the handle server.
try
{
is = new FileInputStream("./" + filename);
if (log.isInfoEnabled())
{
log.info("Loaded configuration from your current working "
+ "directory where you started the handle server.");
}
}
catch (FileNotFoundException ex)
{
if (log.isInfoEnabled())
{
log.info("Can't load config file: " + ex.getMessage());
}
}
}
if (is == null)
{
throw new IllegalStateException("Cannot find configuration.");
}
return is;
}
private void loadPrefixes(String endpoint)
{
URL url = null;
try {
url = new URL(endpoint + "/listprefixes");
} catch (MalformedURLException ex) {
log.error(endpoint + "is not a correct URL, will ignore this "
+ "DSpace instance.", ex);
}
String[] prefixes;
try {
InputStreamReader jsonStreamReader = new InputStreamReader(url.openStream(), "UTF-8");
JsonParser parser = new JsonParser();
JsonElement jsonElement = parser.parse(jsonStreamReader);
if (jsonElement != null && jsonElement.getAsJsonArray().size() != 0)
{
for (int i = 0; i < jsonElement.getAsJsonArray().size(); i++)
{
String prefix = jsonElement.getAsJsonArray().get(i).getAsString();
this.prefixes.put(prefix, endpoint);
if (log.isInfoEnabled())
{
log.info("Mapping " + prefix + " to instance at " + endpoint);
}
}
} else {
log.warn("DSpace instance running at " + url + " returns empty prefix list.");
}
}
catch (Exception ex)
{
log.warn("Error while loading prefixes from " + endpoint + ", ignoring.", ex);
}
}
public static void main(String[] args) throws Exception
{
MultiRemoteDSpaceRepositoryHandlePlugin multi = new MultiRemoteDSpaceRepositoryHandlePlugin();
try
{
System.out.println(StringUtils.join(
multi.getRemoteDSpaceHandles("123456789"), ","));
}
catch (HandleException e)
{
e.printStackTrace();
}
try
{
System.out.println(StringUtils.join(
multi.getRemoteDSpaceHandles("123456780"), ","));
}
catch (HandleException e)
{
e.printStackTrace();
}
try
{
System.out.println(multi.getRemoteDSpaceURL("123456789/1"));
}
catch (HandleException e)
{
e.printStackTrace();
}
try
{
System.out.println(multi.getRemoteDSpaceURL("123456789/1111111"));
}
catch (HandleException e)
{
e.printStackTrace();
}
try
{
System.out.println(multi.getRemoteDSpaceURL("123456780/1"));
}
catch (HandleException e)
{
e.printStackTrace();
}
try
{
System.out.println(multi.getRemoteDSpaceURL("123456780/1111111"));
}
catch (HandleException e)
{
e.printStackTrace();
}
}
}