D-Net

package eu.dnetlib.common.services.locators;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.BeansException;

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

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Sets;

import eu.dnetlib.common.services.ServiceNameResolver;

import eu.dnetlib.rmi.objects.is.DnetDataStructure;

import eu.dnetlib.rmi.objects.is.DnetService;

import eu.dnetlib.rmi.soap.BaseService;

import eu.dnetlib.rmi.soap.InformationService;

import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;

public class DefaultUniqueServiceLocator implements UniqueServiceLocator, ApplicationContextAware {

	private ApplicationContext appContext;

	private Comparator<ServiceRunningInstance> defaultComparator; // = new

	// PreferLocalRunningInstanceComparator();

	/**

	 * An instance of informationService (local or stub)

	 */

	@Resource

	private InformationService informationService;

	/**

	 * logger.

	 */

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

	@PostConstruct

	public void init() {

		log.info("****************************************");

		log.info("*     I'm the new service locator      *");

		log.info("****************************************");

	}

	@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.resolveServiceName(clazz);

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

	}

	@Override

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

		try {

			final String serviceId = getServiceId(clazz, id);

			final DnetService desc = informationService.getService(serviceId);

			return obtainRunningInstance(desc, obtainLocalServices()).obtainClient(clazz);

		} catch (Exception e) {

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

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

		}

	}

	@Override

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

		if (clazz.isInstance(informationService)) { return clazz.cast(informationService); }

		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.resolveServiceName(clazz), comparator).get(0).getServiceId();

	}

	@Override

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

		try {

			if (id.startsWith("service-")) {

				return id;

			} else {

				DnetDataStructure dsById;

				dsById = informationService.getDsById(id);

				if (dsById != null) {

					return dsById.getServiceId();

				} else {

					return null;

				}

			}

		} catch (InformationServiceException e) {

			log.error("Error searching service for resource:" + id);

			return null;

		}

	}

	@Override

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

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

		for (ServiceRunningInstance instance : findRunningInstances(ServiceNameResolver.resolveServiceName(clazz), null)) {

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

		}

		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.resolveServiceName(clazz), null)) {

			res.add(instance.getServiceId());

		}

		return res;

	}

	private synchronized <T extends BaseService> ServiceRunningInstance obtainRunningInstance(

			final DnetService desc, final Map<String, BaseService> locals) {

		final String id = desc.getId();

		final String url = desc.getProtocols().get("SOAP");

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

		final int usedDiskpace = 0; // TODO

		final int handledDatastructures = 0; // TODO

		return new ServiceRunningInstance(id, url, local, usedDiskpace, handledDatastructures, desc.getProperties());

	}

	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<ServiceRunningInstance> instances = Lists.newArrayList();

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

			for (final DnetService s : informationService.listServices()) {

				if (s.getName().equals(serviceName)) {

					instances.add(obtainRunningInstance(s, locals));

				}

			}

			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 (BaseService service : appContext.getBeansOfType(BaseService.class).values()) {

			final DnetService info = service.identify();

			if (info != null && StringUtils.isNotBlank(info.getId())) {

				locals.put(info.getId(), service);

			}

		}

		return locals;

	}

	@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 InformationService getInformationService() {

		return informationService;

	}

	public void setInformationService(final InformationService informationService) {

		this.informationService = informationService;

	}

}