* * This container is used mainly to register a new service in a * Moby registry, and to find registered services later.
*
* @author Martin Senger
* @version $Id: MobyService.java,v 1.28 2009/05/19 21:03:56 kawas Exp $
*/
public class MobyService
implements Comparable
*************************************************************************/
public MobyService (String name, String authority) {
setName (name);
setAuthority (authority);
}
/**
* Generally, you don't need to clone a service, unless you plan on modifying
* fields of the object, but do not want it to affect the service definition
* used by other threads within the JVM (i.e. getService(serviceName) always
* returns the same object within a single JVM instance).
*/
public MobyService clone(){
MobyService clone = new MobyService(getName(), getAuthority());
clone.setId(getId());
clone.setAuthoritative(isAuthoritative());
clone.setEmailContact(getEmailContact());
clone.setCategory(getCategory());
clone.setDescription(getDescription());
clone.setType(getType());
clone.setURL(getURL());
clone.setSignatureURL(getSignatureURL());
clone.setPathToRDF(getPathToRDF());
clone.setRDF(getRDF());
clone.setUnitTests(getUnitTests());
clone.serviceStatus = serviceStatus;
clone.statusChecks = statusChecks;
for(MobyPrimaryData primary: getPrimaryInputs()){
clone.primaryInputs.add(primary.clone());
}
for(MobySecondaryData secondary: getSecondaryInputs()){
clone.secondaryInputs.add(secondary.clone());
}
for(MobyPrimaryData primary: getPrimaryOutputs()){
clone.primaryOutputs.add(primary.clone());
}
return clone;
}
public String getUniqueName() {
return name + "/" + authority;
}
/**
* @param statusCode should be one of ALIVE, PINGED, TESTED
* @param mode whether the service passed the requirement or not
*/
public void setStatus(int statusCode, boolean mode){
if(mode){
serviceStatus |= statusCode;
}
statusChecks |= statusCode;
}
/**
* @return bit-wise combination of ALIVE, PINGED, TESTED states for the service, or DEAD if no tests passed, or UNCHECKED if no tests have been run
*/
public int getStatus(){
if((statusChecks & serviceStatus) != 0){ //some status test passed
return serviceStatus;
}
else if(statusChecks == UNCHECKED){
return UNCHECKED;
}
else{
return DEAD; // failed every test thrown at it so far
}
}
public String getName() {
return name;
}
public void setName (String value) {
name = value;
}
/**
* Return an ID that is given to this service instance during its
* registration. The ID is used only for de-registration of this
* service instance (you are not supposed to fill it when you
* create an instance of this object). But it soon becomes
* obsolete anyway because of the new way of registering services
* (see {@link #getSignatureURL}).
*/
public String getId() {
return id;
}
/**
* Don't use it.
* @see #getId
*/
public void setId (String value) {
id = value;
}
public String getLSID() {
return lsid;
}
public void setLSID (String value) {
lsid = value;
}
public boolean isAuthoritative() {
return authoritativeService;
}
public void setAuthoritative (boolean value) {
authoritativeService = value;
}
public String getAuthority() {
return authority;
}
public void setAuthority (String value) {
authority = (value == null ? "" : value);
}
public String getEmailContact() {
return emailContact;
}
public void setEmailContact (String value) {
emailContact = (value == null ? "" : value);
}
public String getCategory() {
return category;
}
public void setCategory (String value) {
category = (value == null ? CATEGORY_MOBY : value);
}
public String getDescription() {
return description;
}
public void setDescription (String value) {
description = (value == null ? "" : value);
}
public String getType() {
return type;
}
public void setType (String value) {
serviceType = (value == null ? new MobyServiceType() : new MobyServiceType(value));
type = (value == null ? "" : value);
}
/**
*
* @return an array of MobyUnitTest objects set for this service
*/
public MobyUnitTest[] getUnitTests() {
synchronized (unitTests) {
MobyUnitTest[] tests = new MobyUnitTest[unitTests.size()];
unitTests.copyInto(tests);
return tests;
}
}
/**
*
* @param unitTests
* the tests to set for the service
*/
public void setUnitTests(MobyUnitTest[] unitTests) {
if (unitTests == null) {
this.unitTests.clear();
} else {
for (MobyUnitTest mut : unitTests) {
addUnitTest(mut);
}
}
}
/**
*
* @param unitTest the MobyUnitTest to add to our service
*/
public void addUnitTest(MobyUnitTest unitTest) {
if (unitTest != null) {
for (MobyUnitTest t : unitTests) {
// dont add duplicate tests
if (t.toString().equals(unitTest.toString()))
return;
}
unitTests.add(unitTest);
}
}
/**
*
* @param unitTest the test to remove from the set of tests for the service
*/
public void removeUnitTest(MobyUnitTest unitTest) {
if (unitTest != null) {
for (int x = 0; x < unitTests.size(); x++) {
if (unitTest.toString().equals(unitTests.elementAt(x).toString())) {
unitTests.removeElementAt(x);
return;
}
}
}
}
/**
* Return a URL where this service is being served from. It is a
* URL where the clients of this service are going when they want
* to use it.
*
* Note that there is nothing in the BioMoby registry remembering
* (registering) a namespace of your service. Therefore, your
* service is supposed to use always the namespace
* http://biomoby.org.
*/
public String getURL() {
return url;
}
/**
* @see #getURL
*/
public void setURL (String value) {
url = (value == null ? "" : value);
}
/**
* Return a URL pointing to an RDF document that contains this
* service description (signature). Note that this RDF document
* can include also other things, such as other service
* signatures.
*
* This is how it works:
*
*
* TBD: The authority should be checked that it does not contain
* character sequence 'space followed by a left parenthesis'.
*************************************************************************/
public String toShortString() {
return name + " (" + authority + ")";
}
/**************************************************************************
* Create a comparator for case-insensitive sorting of services by
* their authorities.
*************************************************************************/
public static Comparator getAuthorityComparator() {
return new Comparator() {
public int compare (Object o1, Object o2) {
String a1 = ((MobyService)o1).getAuthority();
String a2 = ((MobyService)o2).getAuthority();
int compared = (a1).compareToIgnoreCase ((String)a2);
if (compared == 0)
return ( ((MobyService)o1).getName().compareToIgnoreCase ( ((MobyService)o2).getName() ) );
else
return compared;
}
};
}
/**
*
* @return the MobyServiceType of this service
*/
public MobyServiceType getServiceType() {
return serviceType != null ? serviceType : new MobyServiceType();
}
/**
*
* @param serviceType the MobyServiceType of this service
*/
public void setServiceType(MobyServiceType serviceType) {
this.type = (serviceType == null ? "" : serviceType.getName());
this.serviceType = (serviceType == null ? new MobyServiceType() : serviceType);
}
public static MobyService getService(String lsid){
String[] lsidParts = lsid.split(":");
String[] sNameParts = lsidParts[4].split(",");
return getService(sNameParts[1], sNameParts[0]);
}
public static MobyService getService(String name, String authority){
if(name == null || authority == null){
return null;
}
// Perform a linear search for the corresponding namespace and authority
String lsid = "urn:lsid:biomoby.org:serviceinstance:"+authority+","+name;
if(!serviceMap.containsKey(lsid)){
try{
// Note: when we properly implement LSID resolution in Java (hopefully soon),
// the metadata resolution URL below will come from DNS SRV records...and we'll parse the XML
// rather than using a regex :-)
URL lsidResolver = new URL("http://moby.ucalgary.ca/authority/metadata/?lsid="+lsid);
Object o = getContent(lsidResolver);
if(!(o instanceof String)){
System.err.println("Response for "+lsid + " was not a String, but a " + o.getClass());
}
String metadata = (String) o;
String redirectPattern = "latest>";
int redirectStringIndex = metadata.indexOf(redirectPattern+lsid);
String lsidFull = null;
if(redirectStringIndex != -1){
int lsidFullIndex = redirectStringIndex+redirectPattern.length();
lsidFull = metadata.substring(lsidFullIndex, lsidFullIndex+lsid.length()+21);
//System.err.println("Retrieving full LSID " + lsidFull);
lsidResolver = new URL("http://moby.ucalgary.ca/authority/metadata/?lsid="+lsidFull);
metadata = getContent(lsidResolver);
}
ServiceInstanceParser p = new ServiceInstanceParser();
services = p.getMobyServicesFromRDF(metadata);
if(services.length > 0){
serviceMap.put(lsid, services[0]);
if(lsidFull != null){
serviceMap.put(lsidFull, services[0]);
}
}
} catch(Exception e){
System.err.println("Error while fetching service metadata: " + e);
}
}
return serviceMap.get(lsid);
}
private static String getContent(URL u) throws Exception{
StringBuffer contents = new StringBuffer();
java.io.LineNumberReader reader = new java.io.LineNumberReader(new java.io.InputStreamReader(u.openStream()));
for(String line = reader.readLine(); line != null; line = reader.readLine()){
contents.append(line+"\n");
}
return contents.toString();
}
public boolean isAsynchronous(){
return
category.equals (CATEGORY_MOBY_ASYNC) ||
category.equals (CATEGORY_MOBY_DOCLIT_ASYNC);
}
}
*
*
*/
public String getSignatureURL() {
return signatureURL;
}
/**
* @see #getSignatureURL
*/
public void setSignatureURL (String value) {
signatureURL = (value == null ? "" : value);
}
/**
* @see #getSignatureURL
*/
public String getPathToRDF() {
return pathToRDF;
}
public void setPathToRDF (String value) {
pathToRDF = (value == null ? "" : value);
}
/**
* @see #getSignatureURL
*/
public String getRDF() {
return rdf;
}
public void setRDF (String value) {
rdf = (value == null ? "" : value);
}
/**
* Adds an array of input parameter to the service.
* NOTE: the "set" is a bit of a misnomer: parameters will be added to the existing list.
* To clear the existing list of parameters, call this finction with 'null' first.
*/
public void setInputs (MobyData[] value) {
if (value == null) {
primaryInputs.clear();
secondaryInputs.clear();
} else {
for (int i = 0 ; i < value.length; i++) {
if (value[i].isPrimary())
addOrReplaceData(primaryInputs, value[i]);
else
addOrReplaceData(secondaryInputs, value[i]);
}
}
}
public void addInput (MobyData value) {
if (value != null) {
if (value.isPrimary())
addOrReplaceData(primaryInputs, value);
else
addOrReplaceData(secondaryInputs, value);
}
}
public void removeInput(MobyData value) {
if (value != null) {
if (value.isPrimary())
removeData(primaryInputs, value);
else
removeData(secondaryInputs, value);
}
}
private void addOrReplaceData(Vector