* This class is supposed to be used by all other clients that wish
* to communicate with the Moby Registry, but do not want to know
* about all XML details that are necessary for talking with the Moby Central
* directly. This is an example of a client program:
*
* import org.biomoby.shared.Central;
* import org.biomoby.shared.MobyException;
* import org.biomoby.client.CentralImpl;
* import java.util.Map;
* import java.util.Iterator;
*
* public class Test {
*
* public static void main (String[] args)
* throws MobyException {
*
* Central worker = new CentralImpl();
* Map authorities = worker.getServiceNamesByAuthority();
*
* for (Iterator it = authorities.entrySet().iterator(); it.hasNext(); ) {
* Map.Entry entry = (Map.Entry)it.next();
* System.out.println (entry.getKey());
* String[] names = (String[])entry.getValue();
* for (int i = 0; i < names.length; i++)
* System.out.println ("\t" + names[i]);
* }
* }
* }
*
*
* @author Martin Senger
* @version $Id: CentralImpl.java,v 1.65 2010/04/16 19:59:01 gordonp Exp $
*/
public class CentralImpl
implements Central, SimpleCache {
private URL endpoint;
private String uri;
protected boolean debug = false;
/** Common central used to if getDefaultCentral() is called */
protected static Map defaultCentrals = new HashMap();
/** Default location (endpoint) of a Moby registry. */
public static final String DEFAULT_ENDPOINT = "http://moby.ucalgary.ca/moby/MOBY-Central.pl";
/** Default namespace used by the contacted Moby registry. */
public static final String DEFAULT_NAMESPACE = "http://moby.ucalgary.ca/MOBY/Central";
/**
* The META-INF resource file that will be checked to determine what
* default class should be instantiated in order to create a Central Implementation
* when getDefaultCentral() is called.
*/
public static final String CENTRAL_IMPL_RESOURCE_NAME = "org.biomoby.client.CentralImpl";
/** The class to use for getDefaultCentral if all else fails */
public static final String DEFAULT_CENTRAL_IMPL_CLASSNAME = "org.biomoby.client.CentralDigestCachedImpl";
private static Logger logger = Logger.getLogger(CentralImpl.class.getName());
/**
* Thread local that gives each thread its own
* DocumentBuilderFactory (since it is not thread-safe). Code taken
* from Apache's JaxpUtils.
*/
public static ThreadLocal DOCUMENT_BUILDER_FACTORIES = new ThreadLocal() {
protected synchronized Object initialValue() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware (true);
return dbf;
}
};
/*************************************************************************
* Default constructor. It connects to a default Moby registry
* (as defined in {@link #DEFAULT_ENDPOINT}) using a default namespace
* (as defined int {@link #DEFAULT_NAMESPACE}).
*************************************************************************/
public CentralImpl()
throws MobyException {
this (DEFAULT_ENDPOINT, DEFAULT_NAMESPACE);
}
/*************************************************************************
* Constructor allowing to specify which Moby Registry to use.
*
* @throws MobyException if 'endpoint' is not a valid URL, or if no
* DOM parser is available
*************************************************************************/
public CentralImpl (String endpoint)
throws MobyException {
this (endpoint, DEFAULT_NAMESPACE);
}
/*************************************************************************
* Constructor allowing to specify which Moby Registry and what
* namespace to use. If any of the parameters is null, its default
* value is used instead.
*
* @throws MobyException if 'endpoint' is not a valid URL, or if no
* DOM parser was found
*************************************************************************/
public CentralImpl (String endpoint, String namespace)
throws MobyException {
if (endpoint == null || "".equals (endpoint.trim()))
endpoint = DEFAULT_ENDPOINT;
if (namespace == null || "".equals (namespace.trim()))
namespace = DEFAULT_NAMESPACE;
try {
this.endpoint = new URL (endpoint);
} catch (MalformedURLException e) {
throw new MobyException ("Bad URL: " + endpoint);
}
this.uri = namespace;
cache = new Hashtable();
useCache = true;
}
/*************************************************************************
* Loads a DOM Document from an InputStream. Uses thread-safe
* mechanism.
*************************************************************************/
public static Document loadDocument (InputStream input)
throws MobyException {
try {
DocumentBuilderFactory dbf
= (DocumentBuilderFactory)DOCUMENT_BUILDER_FACTORIES.get();
DocumentBuilder db = dbf.newDocumentBuilder();
return (db.parse (input));
} catch (Exception e) {
throw new MobyException ("Problem with reading XML input: " + e.toString(), e);
}
}
/*************************************************************************
* Call 'method' with 'parameters' and return its result.
*************************************************************************/
protected Object doCall (String method, Object[] parameters)
throws MobyException {
Call call = null;
try {
Service service = new Service();
call = (Call) service.createCall();
call.setTargetEndpointAddress (endpoint);
call.setTimeout (new Integer (0));
call.setSOAPActionURI (uri + "#" + method);
if (debug) {
System.err.println ("METHOD CALL: " + method);
System.err.println ("------------");
if (parameters.length > 0)
System.err.println (parameters[0] + "\n");
System.err.println ("------------\n");
Object result = call.invoke (uri, method, parameters);
System.err.println ("METHOD RETURN:");
System.err.println ("------------");
if (result != null)
System.err.println (result + "\n");
System.err.println ("------------\n");
return resultToString (result);
} else {
return resultToString (call.invoke (uri, method, parameters));
}
} catch (AxisFault e) {
throw new MobyException
(formatFault (e,
endpoint.toString(),
(call == null ? null : call.getOperationName())),
e);
// (endpoint.toString()+(call == null ? "" : call.getOperationName()), e);
} catch (Exception e) {
throw new MobyException (e.toString(), e);
// e.printStackTrace();
}
}
/**************************************************************************
* Parse the given XML sniplet to find tag 'success'. If it has value '1'
* look further for tag 'id' and return it back (or return an empty string
* if ID is not there). Otherwise raise an exception with the 'culprit'
* and with the message from the tag 'message'.
*
* The return value is a two-element long array. The first element
* is the ID (given by BioMobe registry), and the second element
* is RDF corresponding with the registered object (BioMoby
* returns this only for service instances, so for other objects
* this will be null).
*
* This is how the XML is supposed to look:
*
*
*
*
*
*
*
* Success takes the value "1" to indicate success, "0" to
* indicate failure, and "-1" to indicate "Pending Curation".
*************************************************************************/
protected String[] checkRegistration (String xml, Object culprit)
throws MobyException, NoSuccessException, PendingCurationException {
String id = "", success = "0", message = "", rdf = "";
// parse returned XML
Document document = loadDocument (new ByteArrayInputStream (xml.getBytes()));
Element root = document.getDocumentElement();
NodeList children = root.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
if (children.item (i).getNodeType() != Node.ELEMENT_NODE)
continue;
Element elem = (Element)children.item (i);
if (elem.getNodeName().equals ("id")) {
if (elem.getFirstChild() != null)
id = elem.getFirstChild().getNodeValue();
} else if (elem.getNodeName().equals("success")) {
if (elem.getFirstChild() != null)
success = elem.getFirstChild().getNodeValue();
} else if (elem.getNodeName().equals ("message")) {
if (elem.getFirstChild() != null)
message = elem.getFirstChild().getNodeValue();
} else if (elem.getNodeName().equals ("RDF")) {
if (elem.getFirstChild() != null)
rdf = elem.getFirstChild().getNodeValue();
}
}
if (success.equals ("0"))
throw new NoSuccessException (message, culprit);
else if (success.equals ("-1"))
throw new PendingCurationException();
return new String[] { id, rdf };
}
/**************************************************************************
* Return a piece of XML created from the definitions representing input
* data types and their usage in the given service. Only data considered
* primary are included. Note that the main job of converting to XML is
* done by instances of MobyPrimaryData.
*
* The returned XML looks like this:
*
*
*
*************************************************************************/
protected String buildPrimaryInputTag (MobyService service) {
StringBuffer buf = new StringBuffer();
MobyData[] primaryInputs = service.getPrimaryInputs();
buf.append ("\n");
for (int i = 0; i < primaryInputs.length; i++)
buf.append (primaryInputs[i].toXML());
buf.append ("\n");
return new String (buf);
}
/**************************************************************************
* Return a piece of XML created from the definitions representing input
* data types and their usage in the given service. Only data considered
* secondary are included. Note that the main job of converting to XML is
* done by instances of MobySecondaryData.
*
* The returned XML looks like this:
*
*
*
*************************************************************************/
protected String buildSecondaryInputTag (MobyService service) {
StringBuffer buf = new StringBuffer();
MobyData[] secInputs = service.getSecondaryInputs();
buf.append ("\n");
for (int i = 0; i < secInputs.length; i++) {
buf.append (secInputs[i].toXML());
}
buf.append ("\n");
return new String (buf);
}
/**************************************************************************
* Return a piece of XML created from the definitions representing output
* data types and their usage in the given service. Only data considered
* primary are included. Note that the main job of converting to XML is
* done by instances of MobyPrimaryData.
*
* The returned XML looks like this:
*
*
*************************************************************************/
protected String buildOutputTag (MobyService service) {
StringBuffer buf = new StringBuffer();
MobyData[] primaryOutputs = service.getPrimaryOutputs();
buf.append ("\n");
return new String (buf);
}
/**************************************************************************
* Return a piece of XML represented a query object (an object used
* to find a service).
*
* The returned XML looks like this:
*
*
*
*
*
*
*
*
*
* ServiceTypeTerm
* ServiceName
* moby
* http://desired.service.provider;
* 1|0
* 1|0
* 1|0
*
* something
* ....
* ....
*
*************************************************************************/
protected String buildQueryObject (MobyService service,
String[] keywords,
boolean expandObjects,
boolean expandServices,
boolean authoritative) {
if (service == null) {
service = new MobyService ("dummy");
service.setCategory ("");
}
StringBuffer buf = new StringBuffer();
buf.append ("\n\n");
MobyData[] pi = service.getPrimaryInputs();
if (pi.length > 0) {
for (int i = 0; i < pi.length; i++)
buf.append (pi[i].toXML());
}
buf.append ("\n\n");
buf.append ("\n\n\n");
buf.append ("" + service.getType() + "\n");
String name = service.getName();
if (!name.equals ("") && !name.equals ("dummy") && !name.equals (MobyService.DUMMY_NAME))
buf.append ("" + service.getName() + "\n");
String sigURL = service.getSignatureURL();
if (!sigURL.equals (""))
buf.append ("" + sigURL + "\n");
buf.append ("" + service.getCategory() + "\n");
buf.append ("" + service.getAuthority() + "\n");
buf.append ("");
buf.append (expandObjects ? "1" : "0");
buf.append ("\n");
buf.append ("");
buf.append (expandServices ? "1" : "0");
buf.append ("\n");
buf.append ("");
buf.append (authoritative ? "1" : "0");
buf.append ("\n");
buf.append ("\n");
if (keywords != null && keywords.length > 0) {
for (int i = 0; i < keywords.length; i++) {
buf.append ("");
buf.append (keywords[i]);
buf.append ("\n");
}
}
buf.append ("\n");
return new String (buf);
}
/**************************************************************************
* Extract one or more MobyService objects from the given XML piece.
* The XML should look like this:
*
* <Services>
* <Service authURI="authority.URI.here" lsid="..." serviceName="MyService">
* <serviceType>Service_Ontology_Term</serviceType>
* <Category>moby</Category> <!-- or 'cgi' or 'soap' -->
* <contactEmail>your@email.addy.here</contactEmail>
* <signatureURL>http://service.RDF.here</signatureURL>
* <URL>http://service.endpoint.here/scriptname</URL>
* <authoritative>1</authoritative>
* <Input>
* <!-- one or more Simple and/or Complex Primary articles -->
* </Input>
* <Output>
* <!-- one or more Simple and/or Complex Primary articles -->
* </Output>
* <secondaryArticles>
* <!-- one or more Secondary articles -->
* </secondaryArticles>
* <Description><![CDATA[free text description here]]></Description>
* </Service>
* ... <!-- one or more Service blocks may be returned -->
* ...
* ...
* </Services>
*
* @throws MobyException if the XML document is invalid
*************************************************************************/
public MobyService[] extractServices (String xml)
throws MobyException {
Document document = loadDocument (new ByteArrayInputStream (xml.getBytes()));
NodeList list = document.getElementsByTagName ("Service");
MobyService[] results = new MobyService [list.getLength()];
for (int i = 0; i < list.getLength(); i++) {
Element elem = (Element)list.item (i);
MobyService service = new MobyService (elem.getAttribute ("serviceName"));
service.setAuthority (elem.getAttribute ("authURI"));
service.setLSID (elem.getAttribute ("lsid"));
NodeList children = elem.getChildNodes();
for (int j = 0; j < children.getLength(); j++) {
String nodeName = children.item (j).getNodeName();
if (nodeName.equals ("Description")) {
service.setDescription (getFirstValue (children.item (j)));
} else if (nodeName.equals ("Category")) {
service.setCategory (getFirstValue (children.item (j)));
} else if (nodeName.equals ("URL")) {
service.setURL (getFirstValue (children.item (j)));
} else if (nodeName.equals ("signatureURL")) {
service.setSignatureURL (getFirstValue (children.item (j)));
} else if (nodeName.equals ("contactEmail")) {
service.setEmailContact (getFirstValue (children.item (j)));
} else if (nodeName.equals ("serviceType")) {
service.setType (getFirstValue (children.item (j)));
MobyServiceType mst = new MobyServiceType(service.getType());
NamedNodeMap map = (children.item (j).getAttributes());
if (map != null) {
Node node = map.getNamedItemNS(children.item(j).getNamespaceURI(),"lsid");
if (node != null)
mst.setLSID(node.getNodeValue());
}
service.setServiceType(mst);
} else if (nodeName.equals ("authoritative")) {
String authoritative = getFirstValue (children.item (j));
service.setAuthoritative (authoritative.equals ("1") ? true : false);
} else if (nodeName.equals ("Input")) {
//
//
//
// ...
//
//
// ......
// ......
//
//
NodeList inputs = children.item (j).getChildNodes();
for (int k = 0; k < inputs.getLength(); k++) {
if (inputs.item (k).getNodeName().equals ("Simple")) {
MobyPrimaryDataSimple data = new MobyPrimaryDataSimple ((Element)inputs.item (k));
service.addInput (data);
} else if (inputs.item (k).getNodeName().equals ("Collection")) {
MobyPrimaryDataSet data = new MobyPrimaryDataSet ((Element)inputs.item (k));
service.addInput (data);
}
}
} else if (nodeName.equals ("Output")) {
//
NodeList inputs = children.item (j).getChildNodes();
for (int k = 0; k < inputs.getLength(); k++) {
if (inputs.item (k).getNodeName().equals ("Simple")) {
MobyPrimaryDataSimple data = new MobyPrimaryDataSimple ((Element)inputs.item (k));
service.addOutput (data);
} else if (inputs.item (k).getNodeName().equals ("Collection")) {
MobyPrimaryDataSet data = new MobyPrimaryDataSet ((Element)inputs.item (k));
service.addOutput (data);
}
}
} else if (nodeName.equals ("secondaryArticles")) {
//
// ...
//
NodeList parameters = children.item (j).getChildNodes();
for (int k = 0; k < parameters.getLength(); k++) {
if (parameters.item (k).getNodeName().equals ("Parameter")) {
MobySecondaryData data = new MobySecondaryData ((Element)parameters.item (k));
service.addInput (data);
}
}
}
}
results [i] = service;
}
return results;
}
// protect against null values
protected String getFirstValue (Node child) {
Node node = child.getFirstChild();
if (node == null) return "";
String value = node.getNodeValue();
if (value == null) return "";
return value;
}
protected String getFirstValue (NodeList children) {
if (children.item(0) != null && children.item(0).hasChildNodes()) {
children.item(0).normalize();
return getFirstValue (children.item(0));
}
return "";
}
/**************************************************************************
*
* Implementing SimpleCache interface.
*
* Why to have an interface for such trivial thing? Well, because
* I needed to overwrite the caching mechanism in the subclasses
* so I needed to have all caching functions as separate methods -
* that's why I have collect them in an interface.
*
*************************************************************************/
private Hashtable cache; // this is the cache itself
private boolean useCache; // this signal that we are actually caching things
// not used here
public String createId (String rootName,
String semanticType, String syntaxType,
long lastModified,
Properties props) {
return ""; // not used here
}
// check existence of a cached object
public boolean existsInCache (String id) {
synchronized (cache) {
if (useCache) return cache.containsKey (id);
else return false;
}
}
// retrieve from cache
public Object getContents (String id) {
synchronized (cache) {
if (useCache) return cache.get (id);
else return null;
}
}
// cache an object
public void setContents (String id, java.lang.Object data) {
synchronized (cache) {
if (useCache) cache.put (id, data);
}
}
// in this implementation, it clears the whole cache, regardless
// what 'id' is passed
public void removeFromCache (String id) {
cache.clear();
}
/**************************************************************************
*
* And the other methods related to caching (but not part of the
* SimpleCache interface).
*
**************************************************************************/
/**************************************************************************
* By default, caching is enabled to reduce network traffic.
* Setting this to false will clear the cache, and not cache any
* further calls unless it is set to true again.
*
* @param shouldCache whether retrieveXXX call results should be
* cached in case they are called again (i.e. don't request
* MobyCentral every time)
**************************************************************************/
public void setCacheMode (boolean shouldCache) {
useCache = shouldCache;
if (! useCache)
removeFromCache (null);
}
/**************************************************************************
* Find if caching is currently enabled.
*
* @return true if caching is enabled
**************************************************************************/
public boolean getCacheMode(){
return useCache;
}
/**************************************************************************
* Parses and imports the following XML.
*
*
* @deprecated Replaced by {@link
* #getServiceNamesByAuthority}. The reason is that this method
* returns a random result if there are more services with the
* same name but belonging to different authorities.
*
*************************************************************************/
public Map getServiceNames()
throws MobyException {
String result = (String)doCall ("retrieveServiceNames",
new Object[] {});
// parse returned XML
Map results = new TreeMap (getStringComparator());
Document document = loadDocument (new ByteArrayInputStream (result.getBytes()));
NodeList list = document.getElementsByTagName ("serviceName");
for (int i = 0; i < list.getLength(); i++) {
Element elem = (Element)list.item (i);
results.put (elem.getAttribute ("name"),
elem.getAttribute ("authURI"));
}
return results;
}
/**************************************************************************
* Parses and imports the following XML.
*
*
* @return a Map which has authorities as keys, and String arrays
* with service names as a values.
*************************************************************************/
public Map getServiceNamesByAuthority()
throws MobyException {
String result = getServiceNamesByAuthorityAsXML();
return createServicesByAuthorityFromXML (result, true);
}
/**************************************************************************
* Similar to {@link #getServiceNamesByAuthority} but the
* resulting Map contains slightly more.
*
* @return a Map which has authorities as keys, and arrays of
* MobyServices as a values. Each MobyService is filled with its
* name, authority and LSID.
*************************************************************************/
public Map getServicesByAuthority()
throws MobyException {
String result = getServiceNamesByAuthorityAsXML();
return createServicesByAuthorityFromXML (result, false);
}
//
protected String getServiceNamesByAuthorityAsXML()
throws MobyException {
return (String)doCall ("retrieveServiceNames",
new Object[] {});
}
// if onlyNames == true
// Map: authority name -> String[]
// (filled with service namea)
// else
// Map: authority name -> MobyService[]
// (filled with service name, authority and lsid)
protected Map createServicesByAuthorityFromXML (String result,
boolean onlyNames)
throws MobyException {
// parse returned XML
Map results = new TreeMap (getStringComparator());
Document document = loadDocument (new ByteArrayInputStream (result.getBytes()));
NodeList list = document.getElementsByTagName ("serviceName");
for (int i = 0; i < list.getLength(); i++) {
Element elem = (Element)list.item (i);
String name = elem.getAttribute ("name");
String auth = elem.getAttribute ("authURI");
Vector