D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/cnr-service-common/trunk/", "deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "cnr-service-common"}

package eu.dnetlib.enabling.locators;

import java.util.HashMap;

import java.util.Map;

import javax.xml.ws.WebServiceFeature;

import javax.xml.ws.wsaddressing.W3CEndpointReference;

import eu.dnetlib.common.rmi.BaseService;

import eu.dnetlib.soap.cxf.StandaloneCxfEndpointReferenceBuilder;

/**

 * This bean packages the minimum information for describing a service running instance.

 */

public class ServiceRunningInstance {

	private String serviceId;

	private String url;

	private BaseService localService;

	private int usedDiskSpace = 0;

	private int handledDatastructures = 0;

	private Map<String, String> serviceProperties = new HashMap<String, String>();

	public ServiceRunningInstance() {}

	public ServiceRunningInstance(final String serviceId, final String url) {

		this.serviceId = serviceId;

		this.url = url;

	}

	public ServiceRunningInstance(final String serviceId, final String url, final BaseService localService, final int usedDiskSpace,

			final int handledDatastructures, final Map<String, String> serviceProperties) {

		this.serviceId = serviceId;

		this.url = url;

		this.localService = localService;

		this.usedDiskSpace = usedDiskSpace;

		this.handledDatastructures = handledDatastructures;

		this.serviceProperties = serviceProperties;

	}

	public boolean isLocal() {

		return localService != null;

	}

	synchronized public <T extends BaseService> T obtainClient(final Class<T> clazz, final StandaloneCxfEndpointReferenceBuilder eprBuilder) {

		if (isLocal() && clazz.isInstance(localService)) {

			return clazz.cast(localService);

		} else {

			final W3CEndpointReference epr = eprBuilder.getEndpointReference(url, null, null, url + "?wsdl", null, null);

			return epr.getPort(clazz, new WebServiceFeature[] {});

		}

	}

	public String getServiceId() {

		return serviceId;

	}

	public void setServiceId(final String serviceId) {

		this.serviceId = serviceId;

	}

	public String getUrl() {

		return url;

	}

	public void setUrl(final String url) {

		this.url = url;

	}

	public BaseService getLocalService() {

		return localService;

	}

	public void setLocalService(final BaseService localService) {

		this.localService = localService;

	}

	public Map<String, String> getServiceProperties() {

		return serviceProperties;

	}

	public void setServiceProperties(final Map<String, String> serviceProperties) {

		this.serviceProperties = serviceProperties;

	}

	public int getUsedDiskSpace() {

		return usedDiskSpace;

	}

	public void setUsedDiskSpace(final int usedDiskSpace) {

		this.usedDiskSpace = usedDiskSpace;

	}

	public int getHandledDatastructures() {

		return handledDatastructures;

	}

	public void setHandledDatastructures(final int handledDatastructures) {

		this.handledDatastructures = handledDatastructures;

	}

}

package eu.dnetlib.enabling.locators.comparators;

import java.util.Comparator;

import eu.dnetlib.enabling.locators.ServiceRunningInstance;

public class HandledDatastructuresComparator implements Comparator<ServiceRunningInstance> {

	@Override

	public int compare(final ServiceRunningInstance s1, final ServiceRunningInstance s2) {

		return Integer.compare(s1.getHandledDatastructures(), s2.getHandledDatastructures());

	}

}

package eu.dnetlib.enabling.locators.comparators;

import java.util.Comparator;

import eu.dnetlib.enabling.locators.ServiceRunningInstance;

public class PreferLocalRunningInstanceComparator implements Comparator<ServiceRunningInstance> {

	@Override

	public int compare(final ServiceRunningInstance s1, final ServiceRunningInstance s2) {

		if (s1.isLocal()) {

			return -1;

		} else if (s2.isLocal()) {

			return 1;

		} else {

			return 0;

		}

	}

}

package eu.dnetlib.enabling.locators.comparators;

import java.util.Comparator;

import eu.dnetlib.enabling.locators.ServiceRunningInstance;

public class DiskSpaceComparator implements Comparator<ServiceRunningInstance> {

	@Override

	public int compare(final ServiceRunningInstance s0, ServiceRunningInstance s1) {

		return Integer.compare(s0.getUsedDiskSpace(), s1.getUsedDiskSpace());

	}

}

package eu.dnetlib.enabling.locators;

import java.util.Comparator;

import java.util.Set;

import eu.dnetlib.common.rmi.BaseService;

public interface UniqueServiceLocator {

	<T extends BaseService> T getService(Class<T> clazz);

	<T extends BaseService> T getService(Class<T> clazz, Comparator<ServiceRunningInstance> comparator);

	<T extends BaseService> T getService(Class<T> clazz, String profileId);

	<T extends BaseService> T getService(Class<T> clazz, boolean local);

	<T extends BaseService> String getServiceId(Class<T> clazz);

	<T extends BaseService> String getServiceId(Class<T> clazz, Comparator<ServiceRunningInstance> comparator);

	<T extends BaseService> String getServiceId(Class<T> clazz, String profileId);

	<T extends BaseService> Set<T> getAllServices(Class<T> clazz);

	<T extends BaseService> Set<String> getAllServiceIds(Class<T> clazz);

}

package eu.dnetlib.enabling.locators;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.*;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Sets;

import eu.dnetlib.common.rmi.BaseService;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.tools.registration.ServiceNameResolver;

import eu.dnetlib.enabling.tools.registration.ValidatingServiceRegistrationManagerImpl;

import eu.dnetlib.miscutils.collections.EnsureCollection;

import eu.dnetlib.soap.cxf.StandaloneCxfEndpointReferenceBuilder;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.math.NumberUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

public class DefaultUniqueServiceLocator implements UniqueServiceLocator, ApplicationContextAware {

	private ApplicationContext appContext;

	private Comparator<ServiceRunningInstance> defaultComparator; // = new

	// PreferLocalRunningInstanceComparator();

	/**

	 * An instance of isLookupService (local or stub)

	 */

	@Autowired

	private ISLookUpService isLookupService;

	@Autowired

	private ServiceNameResolver serviceNameResolver;

	/**

	 * XML Parser

	 */

	private SAXReader reader = new SAXReader();

	/**

	 * build epr.

	 */

	@Autowired

	private StandaloneCxfEndpointReferenceBuilder eprBuilder;

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(DefaultUniqueServiceLocator.class);

	@Override

	public <T extends BaseService> T getService(final Class<T> clazz) {

		return getService(clazz, true);

	}

	@Override

	public <T extends BaseService> T getService(final Class<T> clazz, final Comparator<ServiceRunningInstance> comparator) {

		final String serviceName = serviceNameResolver.getName(clazz);

		return findRunningInstances(serviceName, comparator).get(0).obtainClient(clazz, eprBuilder);

	}

	@Override

	public <T extends BaseService> T getService(final Class<T> clazz, final String profileId) {

		final String profile = obtainServiceProfile(profileId);

		try {

			return obtainRunningInstance(profile, obtainLocalServices()).obtainClient(clazz, eprBuilder);

		} catch (Exception e) {

			log.error("cannot instantiate service from id: " + profileId, e);

			throw new IllegalStateException("cannot instantiate service from id: " + profileId, e);

		}

	}

	@Override

	public <T extends BaseService> T getService(final Class<T> clazz, final boolean local) {

		if (clazz.isInstance(isLookupService)) return clazz.cast(isLookupService);

		if (local) {

			try {

				final Map<String, T> beans = appContext.getBeansOfType(clazz);

				if ((beans != null) && !beans.isEmpty()) return beans.values().iterator().next();

			} catch (Throwable e) {

				log.warn("No beans found in context, class " + clazz);

			}

		}

		return getService(clazz, defaultComparator);

	}

	@Override

	public <T extends BaseService> String getServiceId(final Class<T> clazz) {

		return getServiceId(clazz, defaultComparator);

	}

	@Override

	public <T extends BaseService> String getServiceId(final Class<T> clazz, final Comparator<ServiceRunningInstance> comparator) {

		return findRunningInstances(serviceNameResolver.getName(clazz), comparator).get(0).getServiceId();

	}

	@Override

	public <T extends BaseService> String getServiceId(final Class<T> clazz, final String profileId) {

		final String profile = obtainServiceProfile(profileId);

		final ServiceRunningInstance instance = obtainRunningInstance(profile, obtainLocalServices());

		return instance.getServiceId();

	}

	@Override

	public <T extends BaseService> Set<T> getAllServices(final Class<T> clazz) {

		final Set<T> res = Sets.newHashSet();

		for (ServiceRunningInstance instance : findRunningInstances(serviceNameResolver.getName(clazz), null)) {

			res.add(instance.obtainClient(clazz, eprBuilder));

		}

		return res;

	}

	@Override

	public <T extends BaseService> Set<String> getAllServiceIds(final Class<T> clazz) {

		final Set<String> res = Sets.newHashSet();

		for (ServiceRunningInstance instance : findRunningInstances(serviceNameResolver.getName(clazz), null)) {

			res.add(instance.getServiceId());

		}

		return res;

	}

	private synchronized <T extends BaseService> ServiceRunningInstance obtainRunningInstance(final String profile, final Map<String, BaseService> locals) {

		try {

			final Document doc = reader.read(new StringReader(profile));

			final String url = doc.valueOf("//PROTOCOL[@name = 'SOAP']/@address");

			final String id = doc.valueOf("//RESOURCE_IDENTIFIER/@value");

			final Map<String, String> props = Maps.newHashMap();

			final BaseService local = locals.containsKey(id) ? locals.get(id) : null;

			final int usedDiskpace = NumberUtils.toInt(doc.valueOf("//USED_DISKSPACE"), 0);

			final int handledDatastructures = NumberUtils.toInt(doc.valueOf("//HANDLED_DATASTRUCTURE"), 0);;

			for (Object o : doc.selectNodes("//SERVICE_PROPERTIES/PROPERTY")) {

				final Element p = (Element) o;

				props.put(p.valueOf("@key"), p.valueOf("@value"));

			}

			return new ServiceRunningInstance(id, url, local, usedDiskpace, handledDatastructures, props);

		} catch (DocumentException e) {

			log.error("Error parsing profile: " + profile, e);

			throw new RuntimeException("Error parsing profile: " + profile, e);

		}

	}

	private List<ServiceRunningInstance> findRunningInstances(final String serviceName, final Comparator<ServiceRunningInstance> comparator) {

		final List<ServiceRunningInstance> list = findRegisteredServices(serviceName);

		if (list.isEmpty()) {

			log.error("Service not found, name: " + serviceName);

			throw new RuntimeException("Service not found, name: " + serviceName);

		}

		if (comparator != null) {

			Collections.sort(list, comparator);

		}

		return list;

	}

	private List<ServiceRunningInstance> findRegisteredServices(final String serviceName) {

		log.debug("searching for service: " + serviceName);

		final String xquery = "for $x in collection('/db/DRIVER/ServiceResources/" + serviceName + "ResourceType') return $x";

		log.debug(xquery);

		try {

			final List<String> services = isLookupService.quickSearchProfile(xquery);

			final List<ServiceRunningInstance> instances = Lists.newArrayList();

			final Map<String, BaseService> locals = obtainLocalServices();

			for (final String source : EnsureCollection.list(services)) {

				final ServiceRunningInstance instance = obtainRunningInstance(source, locals);

				instances.add(instance);

			}

			return instances;

		} catch (final Exception e) {

			throw new IllegalStateException("cannot locate service " + serviceName, e);

		}

	}

	private Map<String, BaseService> obtainLocalServices() {

		final Map<String, BaseService> locals = Maps.newHashMap();

		for (ValidatingServiceRegistrationManagerImpl r : appContext.getBeansOfType(ValidatingServiceRegistrationManagerImpl.class).values()) {

			if (r.getService() instanceof BaseService) {

				if (!StringUtils.isBlank(r.getProfileId())) {

					final BaseService baseService = (BaseService) r.getService();

					if (baseService != null) {

						locals.put(r.getProfileId(), baseService);

						log.debug(" -> Service: " + r.getService().getClass().getName() + " has id " + r.getServiceProfile().getResourceId());

					}

				}

			}

		}

		return locals;

	}

	private String obtainServiceProfile(final String profileId) {

		final StringWriter sw = new StringWriter();

		sw.append("let $uri:=/RESOURCE_PROFILE/HEADER[./RESOURCE_IDENTIFIER/@value='");

		sw.append(profileId);

		sw.append("']/RESOURCE_URI/@value/string()");

		sw.append("\n\n");

		sw.append("for $x in collection('/db/DRIVER/ServiceResources')");

		sw.append("\n");

		sw.append("where $x/RESOURCE_PROFILE/HEADER/RESOURCE_URI/@value = $uri");

		sw.append("\n");

		sw.append("return $x");

		final String xq = sw.toString();

		try {

			return isLookupService.getResourceProfileByQuery(xq);

		} catch (ISLookUpException e) {

			log.error("cannot locate service using query: " + xq, e);

			throw new IllegalStateException("cannot locate service using query: " + xq, e);

		}

	}

	@Override

	public void setApplicationContext(final ApplicationContext appContext) throws BeansException {

		this.appContext = appContext;

	}

	public Comparator<ServiceRunningInstance> getDefaultComparator() {

		return defaultComparator;

	}

	@Required

	public void setDefaultComparator(final Comparator<ServiceRunningInstance> defaultComparator) {

		this.defaultComparator = defaultComparator;

	}

	public ISLookUpService getIsLookupService() {

		return isLookupService;

	}

	public void setIsLookupService(final ISLookUpService isLookupService) {

		this.isLookupService = isLookupService;

	}

	public ServiceNameResolver getServiceNameResolver() {

		return serviceNameResolver;

	}

	public void setServiceNameResolver(final ServiceNameResolver serviceNameResolver) {

		this.serviceNameResolver = serviceNameResolver;

	}

}

package eu.dnetlib.enabling.common;

public class StoppableDetails {

	public enum StopStatus {

		RUNNING, STOPPED, STOPPING

	}

	private String name;

	private String message;

	private StopStatus status;

	public StoppableDetails() {}

	public StoppableDetails(String name, String message, StopStatus status) {

		this.name = name;

		this.message = message;

		this.status = status;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getMessage() {

		return message;

	}

	public void setMessage(String message) {

		this.message = message;

	}

	public StopStatus getStatus() {

		return status;

	}

	public void setStatus(StopStatus status) {

		this.status = status;

	}

}

package eu.dnetlib.enabling.common;

public interface Stoppable {

	void stop();

	void resume();

	StoppableDetails getStopDetails();

}

package eu.dnetlib.enabling.is.registry.schema;

import eu.dnetlib.enabling.tools.OpaqueResource;

/**

 * validates the conformity of a resource to a give resource type.

 * 

 * @author marko

 * 

 */

public interface OpaqueResourceValidator {

	/**

	 * check if the given resource is valid according to it's schema.

	 * 

	 * @param resource opaque resource

	 * @throws ValidationException thrown if the validation fails, along with a description of the cause.

	 */

	void validate(OpaqueResource resource) throws ValidationException;

}

package eu.dnetlib.enabling.is.registry.schema;

/**

 * encapsulates a schema validation exception.

 * 

 * @author marko

 *

 */

public class ValidationException extends Exception {

	/**

	 * version.

	 */

	private static final long serialVersionUID = -6886927707534508655L;

	/**

	 * construct a validation exception based upon an encapsulated cause.

	 * @param cause cause

	 */

	public ValidationException(final Throwable cause) {

		super(cause);

	}

	/**

	 * construct a validation exception with a message.

	 * 

	 * @param message message

	 */

	public ValidationException(final String message) {

		super(message);

	}

}

package eu.dnetlib.enabling.is.store;

import java.io.IOException;

import java.io.StringWriter;

import java.net.URL;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.xpath.XPathExpressionException;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Required;

import org.xml.sax.SAXException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryService;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.enabling.tools.StreamOpaqueResource;

/**

 * Abstract resource loading code.

 * 

 * @author marko, michele

 * 

 */

public class AbstractContentInitializer {

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(AbstractContentInitializer.class); // NOPMD by marko on 11/24/08 5:02 PM

	/**

	 * service locator.

	 */

	private UniqueServiceLocator serviceLocator;

	/**

	 * helper class used to bypass the registry and import resources as-is from a backup dump.

	 */

	private BulkResourceImporter bulkImporter;

	private int timeToSleep;

	/**

	 * register a schema from a local resource.

	 * 

	 * @param url

	 *            url

	 * @throws IOException

	 *             happens

	 * @throws ISRegistryException

	 *             could happen

	 */

	protected void registerSchema(final URL url) throws IOException, ISRegistryException {

		final String resourceType = FilenameUtils.getBaseName(url.getPath());

		log.debug("registering schema: " + resourceType);

		final StringWriter writer = new StringWriter();

		IOUtils.copy(url.openStream(), writer);

		ISRegistryService service = null;

		while (service == null) {

			try {

				service = serviceLocator.getService(ISRegistryService.class, true);

				service.addResourceType(resourceType, writer.getBuffer().toString());

				log.info("The is registry service is ready ");

			} catch (Exception e) {

				log.fatal("The is registry service is not ready ", e);

				try {

					Thread.sleep(timeToSleep);

				} catch (InterruptedException e1) {

					log.error(e1);

				}

			}

		}

	}

	/**

	 * register a profile from a local resource.

	 * 

	 * @param url

	 *            url

	 * @throws IOException

	 *             could happen

	 * @throws ISRegistryException

	 *             could happen

	 * @throws ParserConfigurationException

	 *             could happen

	 * @throws SAXException

	 *             could happen

	 * @throws XPathExpressionException

	 *             could happen

	 */

	protected void registerProfile(final URL url) throws IOException, ISRegistryException, XPathExpressionException, SAXException, ParserConfigurationException {

		log.debug("registering profile: " + url);

		bulkImporter.importResource(new StreamOpaqueResource(url.openStream()));

	}

	@Required

	public void setBulkImporter(final BulkResourceImporter bulkImporter) {

		this.bulkImporter = bulkImporter;

	}

	public BulkResourceImporter getBulkImporter() {

		return bulkImporter;

	}

	/**

	 * @return the timeToSleep

	 */

	public int getTimeToSleep() {

		return timeToSleep;

	}

	/**

	 * @param timeToSleep

	 *            the timeToSleep to set

	 */

	@Required

	public void setTimeToSleep(final int timeToSleep) {

		this.timeToSleep = timeToSleep;

	}

	public UniqueServiceLocator getServiceLocator() {

		return serviceLocator;

	}

	@Required

	public void setServiceLocator(final UniqueServiceLocator serviceLocator) {

		this.serviceLocator = serviceLocator;

	}

}

package eu.dnetlib.enabling.is.store;

import org.springframework.beans.factory.annotation.Required;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryException;

import eu.dnetlib.enabling.is.registry.schema.OpaqueResourceValidator;

import eu.dnetlib.enabling.is.registry.schema.ValidationException;

import eu.dnetlib.enabling.is.store.rmi.ISStoreException;

import eu.dnetlib.enabling.is.store.rmi.ISStoreService;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.enabling.tools.OpaqueResource;

import eu.dnetlib.enabling.tools.XQueryUtils;

/**

 * This class implements a bulk resource import, i.e. importing stuff straight into the store, bypassing checks and policies imposed by the

 * registry service.

 * 

 * TODO: move from registry based to store based.

 * 

 * @author marko

 * 

 */

public class BulkResourceImporter {

	/**

	 * xquery utils, needed to map resources with the xmldb collection names.

	 */

	private XQueryUtils xqueryUtils;

	/**

	 * service locator.

	 */

	private UniqueServiceLocator serviceLocator;

	/**

	 * resource validator.

	 */

	private OpaqueResourceValidator resourceValidator;

	/**

	 * set to false to skip validation.

	 */

	private boolean validating = true;

	/**

	 * bulk loading enabled.

	 */

	private boolean enabled = true;

	/**

	 * register a resource bypassing the checks.

	 * 

	 * @param resource

	 *            a resource

	 * @throws ISRegistryException

	 *             could happen

	 */

	public void importResource(final OpaqueResource resource) throws ISRegistryException {

		try {

			if (validating) {

				resourceValidator.validate(resource);

			}

			serviceLocator.getService(ISStoreService.class, true).insertXML(xqueryUtils.getFileName(resource), xqueryUtils.getCollectionAbsPath(resource),

					resource.asString());

		} catch (final ISStoreException e) {

			throw new ISRegistryException(e);

		} catch (final ValidationException e) {

			throw new ISRegistryException(e);

		}

	}

	public XQueryUtils getXqueryUtils() {

		return xqueryUtils;

	}

	@Required

	public void setXqueryUtils(final XQueryUtils xqueryUtils) {

		this.xqueryUtils = xqueryUtils;

	}

	@Required

	public void setResourceValidator(final OpaqueResourceValidator resourceValidator) {

		this.resourceValidator = resourceValidator;

	}

	public OpaqueResourceValidator getResourceValidator() {

		return resourceValidator;

	}

	public void setValidating(final boolean validating) {

		this.validating = validating;

	}

	public boolean isValidating() {

		return validating;

	}

	public boolean isEnabled() {

		return enabled;

	}

	public void setEnabled(final boolean enabled) {

		this.enabled = enabled;

	}

	public UniqueServiceLocator getServiceLocator() {

		return serviceLocator;

	}

	@Required

	public void setServiceLocator(final UniqueServiceLocator serviceLocator) {

		this.serviceLocator = serviceLocator;

	}

}

package eu.dnetlib.enabling.tools;

import java.net.MalformedURLException;

import java.net.URL;

import javax.annotation.Resource;

import eu.dnetlib.soap.cxf.StandaloneCxfEndpointReferenceBuilder;

/**

 * Assign better scores for near services. Can be configured.

 * 

 * @author marko

 *

 */

@Deprecated

public class DefaultServiceLocatorLocationScorer implements DynamicServiceLocatorLocationScorer {

	/**

	 * default score assigned when the other service has the same host.

	 */

	private static final int LOCAL_HOST_SCORE = 5;

	/**

	 * default score assigned when the other service has the same host and port (same container).

	 */

	private static final int LOCAL_PORT_SCORE = 10;

	/**

	 * default score assigned when the other service has the same host and port (same container and context).

	 */

	private static final int LOCAL_SRV_SCORE = 15;

	/**

	 * score assigned when the other service has the same host.

	 */

	private int localHostScore = LOCAL_HOST_SCORE;

	/**

	 * score assigned when the other service has the same host and port (same container).

	 */

	private int localPortScore = LOCAL_PORT_SCORE;

	/**

	 * score assigned when the other service has the same host and port (same container and context).

	 */

	private int localSrvScore = LOCAL_SRV_SCORE; 

	/**

	 * build epr.

	 */

	@Resource

	private StandaloneCxfEndpointReferenceBuilder eprBuilder;

	/** 

	 * {@inheritDoc}

	 * @throws MalformedURLException 

	 * @see eu.dnetlib.enabling.tools.DynamicServiceLocatorLocationScorer#score(java.net.URL)

	 */

	@Override

	public int score(final URL url) throws MalformedURLException {

		final URL localBase = new URL(eprBuilder.getBaseAddress());

		if (url.toString().startsWith(localBase.toString()))

			return localSrvScore;

		if (localBase.getHost().equals(url.getHost())) {

			if (localBase.getPort() == url.getPort())

				return localPortScore;

			return localHostScore;

		}

		return 0;

	}

	public StandaloneCxfEndpointReferenceBuilder getEprBuilder() {

		return eprBuilder;

	}

	public void setEprBuilder(final StandaloneCxfEndpointReferenceBuilder eprBuilder) {

		this.eprBuilder = eprBuilder;

	}

	public int getLocalHostScore() {

		return localHostScore;

	}

	public void setLocalHostScore(final int localHostScore) {

		this.localHostScore = localHostScore;

	}

	public int getLocalPortScore() {

		return localPortScore;

	}

	public void setLocalPortScore(final int localPortScore) {

		this.localPortScore = localPortScore;

	}

	public int getLocalSrvScore() {

		return localSrvScore;

	}

	public void setLocalSrvScore(final int localSrvScore) {

		this.localSrvScore = localSrvScore;

	}

}

package eu.dnetlib.enabling.tools;

import java.net.MalformedURLException;

import java.net.URL;

/**

 * Implementors of this interface provide custom methods to assign scores to services based solely on their location.

 * @author marko

 *

 */

@Deprecated

public interface DynamicServiceLocatorLocationScorer {

	/**

	 * Compute the score assigned to a given service location (url).

	 * 

	 * @param url service url

	 * @return score (the higher the better)

	 * @throws MalformedURLException could happen

	 */

	int score(URL url) throws MalformedURLException;

}

package eu.dnetlib.enabling.tools;

/**

 * simplest HNM locator: doesn't find any.

 * 

 * @author marko

 * 

 */

public class NullHNMLocator implements HNMLocator {

	/**

	 * {@inheritDoc}

	 * 

	 * @see eu.dnetlib.enabling.tools.HNMLocator#getHNMForUrl(java.lang.String)

	 */

	@Override

	public String getHNMForUrl(final String url) {

		return "";

	}

}

package eu.dnetlib.enabling.tools;

import java.io.StringWriter;

import java.util.Date;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.TransformerFactoryConfigurationError;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import eu.dnetlib.miscutils.datetime.DateUtils;

/**

 * OpaqueResource holding a plain old DOM document.

 *

 * @author marko

 *

 */

public class DOMOpaqueResource implements OpaqueResource {

	/**

	 * xpath expression error message.

	 */

	private static final String XPATH_ERROR = "cannot compile xpath expression";

	/**

	 * value attribute.

	 */

	private static final String VALUE_ATTR = "value";

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(DOMOpaqueResource.class); // NOPMD by marko on 11/24/08 5:02 PM

	/**

	 * resource identifier.

	 */

	private String resourceId;

	/**

	 * resource type.

	 */

	private String resourceType;

	/**

	 * resource kind.

	 */

	private String resourceKind;

	/**

	 * resource uri.

	 */

	private String resourceUri;

	/**

	 * modification time stamp.

	 */

	private Date modificationDate;

	/**

	 * original document DOM.

	 */

	private Document dom;

	/**

	 * xslt transformer instance.

	 */

	private Transformer transformer;

	/**

	 * construct a DOMOpaqueInstance from a W3C DOM document.

	 *

	 * @param dom

	 *            DOM document

	 * @throws XPathExpressionException

	 *             happens

	 */

	public DOMOpaqueResource(final Document dom) throws XPathExpressionException {

		this.dom = dom;

		try {

			transformer = TransformerFactory.newInstance().newTransformer();

		} catch (TransformerConfigurationException e) {

			throw new IllegalStateException("transformer configuration", e);

		} catch (TransformerFactoryConfigurationError e) {

			throw new IllegalStateException("transformer configuration", e);

		}

		final XPath xpath = XPathFactory.newInstance().newXPath();

		this.resourceId = xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_IDENTIFIER/@value", dom);

		this.resourceType = xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_TYPE/@value", dom);

		this.resourceKind = xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_KIND/@value", dom);

		this.resourceUri = xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_URI/@value", dom);

		String modificationDateSource = xpath.evaluate("/RESOURCE_PROFILE/HEADER/DATE_OF_CREATION/@value", dom);

		try {

			this.modificationDate = new DateUtils().parse(modificationDateSource);

		} catch (IllegalStateException e) {

			log.debug("invalid date '" + modificationDateSource + "'", e);

		}

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#asDom()

	 */

	@Override

	public Document asDom() {

		return getDom();

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#asString()

	 */

	@Override

	public String asString() {

		final StringWriter writer = new StringWriter();

		try {

			transformer.transform(new DOMSource(getDom()), new StreamResult(writer));

		} catch (TransformerException e) {

			log.fatal("cannot serialize document", e);

			return null;

		}

		return writer.toString();

	}

	public Document getDom() {

		return dom;

	}

	public void setDom(final Document dom) {

		this.dom = dom;

	}

	@Override

	public String getResourceId() {

		return resourceId;

	}

	@Override

	public String getResourceType() {

		return resourceType;

	}

	public void setResourceType(final String resourceType) {

		this.resourceType = resourceType;

	}

	@Override

	public String getResourceKind() {

		return resourceKind;

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#setResourceKind(java.lang.String)

	 */

	@Override

	public void setResourceKind(final String resourceKind) {

		try {

			final XPath xpath = XPathFactory.newInstance().newXPath();

			final Element kindEl = (Element) xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_KIND", asDom(), XPathConstants.NODE);

			kindEl.setAttribute(VALUE_ATTR, resourceKind);

			this.resourceKind = resourceKind;

		} catch (XPathExpressionException e) {

			throw new IllegalStateException(XPATH_ERROR, e);

		}

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#setResourceId(java.lang.String)

	 */

	@Override

	public void setResourceId(final String identifier) {

		try {

			final XPath xpath = XPathFactory.newInstance().newXPath();

			final Element idEl = (Element) xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_IDENTIFIER", asDom(), XPathConstants.NODE);

			idEl.setAttribute(VALUE_ATTR, identifier);

			resourceId = identifier;

		} catch (XPathExpressionException e) {

			throw new IllegalStateException(XPATH_ERROR, e);

		}

	}

	@Override

	public Date getModificationDate() {

		return modificationDate;

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#setModificationDate(java.util.Date)

	 */

	@Override

	public void setModificationDate(final Date modificationDate) {

		try {

			final XPath xpath = XPathFactory.newInstance().newXPath();

			final Element idEl = (Element) xpath.evaluate("/RESOURCE_PROFILE/HEADER/DATE_OF_CREATION", asDom(), XPathConstants.NODE);

			if (idEl == null) {

				log.warn("resource with type " + getResourceType() + " has no date of creation element");

				return;

			}

			idEl.setAttribute(VALUE_ATTR, new DateUtils(modificationDate).getDateAsISO8601String());

			this.modificationDate = modificationDate;

		} catch (XPathExpressionException e) {

			throw new IllegalStateException(XPATH_ERROR, e);

		}

	}

	@Override

	public String getResourceUri() {

		return resourceUri;

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.enabling.tools.OpaqueResource#setResourceUri(java.lang.String)

	 */

	@Override

	public void setResourceUri(final String resourceUri) {

		try {

			final XPath xpath = XPathFactory.newInstance().newXPath();

			final Element uriEl = (Element) xpath.evaluate("/RESOURCE_PROFILE/HEADER/RESOURCE_URI", asDom(), XPathConstants.NODE);

			uriEl.setAttribute(VALUE_ATTR, resourceUri);

			this.resourceUri = resourceUri;

		} catch (XPathExpressionException e) {

			throw new IllegalStateException(XPATH_ERROR, e);

		}

	}

	public Transformer getTransformer() {

		return transformer;

	}

	public void setTransformer(final Transformer transformer) {

		this.transformer = transformer;

	}

}

package eu.dnetlib.enabling.tools;

import java.util.Date;

import org.w3c.dom.Document;

/**

 * Some services, in particular the enabling layer, needs to manipulate all types of resources without knowing the exact

 * structure of their content, but only some well defined properties defined here.

 * 

 * <p>

 * Different wrappers can be provided for different kind of resources. For example resources returned from the xmldb

 * layer can be cheaply mapped to an OpaqueResource, without going to full xml->bean conversion.

 * </p>

 * 

 * @author marko

 * 

 */

public interface OpaqueResource {

	/**

	 * Resource type.

	 * 

	 * @return resource type string

	 */

	String getResourceType();

	/**

	 * Resource kind.

	 * 

	 * @return resource kind string

	 */

	String getResourceKind();

	/**

	 * Resource identifier.

	 * 

	 * @return resource identifier string

	 */

	String getResourceId();

	/**

	 * Resource URI.

	 * 

	 * @return resource uri string

	 */

	String getResourceUri();

	/**

	 * get modification time stamp.

	 * 

	 * @return time stamp

	 */

	Date getModificationDate();

	/**

	 * Implementors may need to serialize the resource to a xml string representation.

	 * 

	 * @return xml serialization

	 */

	String asString();

	/**

	 * Implementors may store the DOM in the first place. Otherwise they should

	 * return a parsed w3c DOM instance.

	 * 

	 * @return DOM document

	 */

	Document asDom();

	/**

	 * change the resource identifier.

	 * 

	 * @param identifier new identifier

	 */

	void setResourceId(String identifier);

	/**

	 * change the resource kind.

	 * 

	 * @param kind new kind

	 */

	void setResourceKind(String kind);

	/**

	 * change the resource uri.

	 * 

	 * @param uri new uri

	 */

	void setResourceUri(String uri);

	/**

	 * set modification timestamp.

	 * 

	 * @param timeStamp modification time stamp

	 */

	void setModificationDate(Date timeStamp);

}

package eu.dnetlib.enabling.tools;

import java.util.List;

/**

 * A service enumerator returns a bunch of service descriptions. The logic depends on the service enumerator.

 *

 * @author marko

 *

 */

@Deprecated

public interface ServiceEnumerator<T> {

	/**

	 * Obtain a list of services.

	 *

	 * @return a list of service running instance descriptions

	 */

	List<ServiceRunningInstance<T>> getServices();

}

package eu.dnetlib.enabling.tools;

/**

 * finds an HNM profile for a giver service url.

 * 

 * @author marko

 * 

 */

public interface HNMLocator {

	/**

	 * finds an HNM profile for a giver service url.

	 * 

	 * @param url

	 *            service address

	 * @return hnm id

	 */

	String getHNMForUrl(String url);

}

package eu.dnetlib.enabling.tools;

import java.io.IOException;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.ws.wsaddressing.W3CEndpointReference;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Required;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.tools.registration.ServiceNameResolver;

import eu.dnetlib.miscutils.collections.EnsureCollection;

import eu.dnetlib.soap.cxf.StandaloneCxfEndpointReferenceBuilder;

/**

 * Enumerates all services of a given type.

 *

 * @author marko

 *

 * @param <T>

 *            service class

 */

@Deprecated

public class DynamicServiceEnumerator<T> implements ServiceEnumerator<T> {

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(DynamicServiceEnumerator.class); // NOPMD by marko on 11/24/08 5:02 PM

	/**

	 * service class

	 */

	private Class<T> clazz;