D-Net

package eu.dnetlib.common.services;

import java.util.Date;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

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.factory.annotation.Required;

import com.google.common.collect.Maps;

import eu.dnetlib.common.services.locators.UniqueServiceLocator;

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

import eu.dnetlib.rmi.soap.BaseService;

import eu.dnetlib.rmi.soap.InformationService;

public class DnetServiceRegistrator {

	@Resource

	private UniqueServiceLocator serviceLocator;

	private static final ExecutorService executor = Executors.newFixedThreadPool(10);

	private BaseService service;

	private String mainProtocol = "SOAP";

	private Map<String, String> properties = Maps.newHashMap();

	private Map<String, String> protocols = Maps.newHashMap();

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

	@PostConstruct

	public void registerService() throws InterruptedException, ExecutionException {

		final String addr = protocols.get(mainProtocol);

		if (StringUtils.isNotBlank(addr)) {

			final DnetService srv = new DnetService();

			srv.setName(ServiceNameResolver.resolveServiceName(service.getClass()));

			srv.setDate(new Date());

			srv.setValid(true);

			srv.setProtocols(protocols);

			srv.setProperties(properties);

			final Future<String> future = executor.submit(new Callable<String>() {

				@Override

				public String call() throws Exception {

					int i = 1;

					while (true) {

						try {

							final InformationService is = getInformationService();

							if (is != null) {

								return is.registerService(srv);

							} else {

								log.warn("Service registration delayed (infomationService not found) - try: " + i++);

								Thread.sleep(2000);

							}

						} catch (Throwable e) {

							log.warn("Service registration delayed (" + e.getMessage() + ") - try: " + i++);

							log.debug("Failed registration", e);

							Thread.sleep(2000);

						}

					}

				}

			});

			srv.setId(future.get());

			log.info("Service " + srv + " registered/updated");

			if (service instanceof AbstractBaseService) {

				((AbstractBaseService) service).setDescription(srv);

			}

		} else {

			log.error("MainProtocol " + mainProtocol + " is missing, service: " + service.getClass());

		}

	}

	private InformationService getInformationService() {

		return service instanceof InformationService ?

				(InformationService) service : serviceLocator.getService(InformationService.class);

	}

	public BaseService getService() {

		return service;

	}

	@Required

	public void setService(final BaseService service) {

		this.service = service;

	}

	public Map<String, String> getProtocols() {

		return protocols;

	}

	@Required

	public void setProtocols(final Map<String, String> protocols) {

		this.protocols = protocols;

	}

	public Map<String, String> getProperties() {

		return properties;

	}

	public void setProperties(final Map<String, String> properties) {

		this.properties = properties;

	}

	public String getMainProtocol() {

		return mainProtocol;

	}

	public void setMainProtocol(final String mainProtocol) {

		this.mainProtocol = mainProtocol;

	}

}