D-Net

package eu.dnetlib.services;

import java.io.File;

import java.lang.annotation.Annotation;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.annotation.PostConstruct;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Element;

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

import org.springframework.context.Lifecycle;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.client.RestTemplate;

import eu.dnetlib.conf.DnetGenericApplicationProperties;

import eu.dnetlib.enabling.annotations.DnetService;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.exceptions.DnetGenericException;

import eu.dnetlib.exceptions.DnetGenericRuntimeException;

import eu.dnetlib.services.async.AsyncClientUtils;

import eu.dnetlib.services.async.AsyncResponse;

import eu.dnetlib.services.async.HasAsyncMethods;

import eu.dnetlib.services.async.ResponseAck;

import eu.dnetlib.services.async.ResponseAck.ResponseAckStatus;

public abstract class BaseService implements Lifecycle {

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

	private boolean started = false;

	private String profileId;

	private String baseUrl;

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

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

	private DnetServiceType serviceType;

	@Autowired

	private DnetGenericApplicationProperties containerConfiguration;

	@Autowired

	private AsyncClientUtils asyncClientUtils;

	@PostConstruct

	public void init() throws DnetGenericException {

		verifyRequiredAnnotations(DnetService.class);

		verifyRequiredAnnotations(RestController.class);

		verifyRequiredAnnotations(RequestMapping.class);

		serviceType = getClass().getAnnotation(DnetService.class).value();

		baseUrl = containerConfiguration.getUrl() + getClass().getAnnotation(RequestMapping.class).value()[0];

		final File dir = new File(containerConfiguration.getBaseDir());

		if (!dir.exists()) {

			dir.mkdirs();

		}

	}

	private void verifyRequiredAnnotations(final Class<? extends Annotation> a) throws DnetGenericException {

		if (!getClass().isAnnotationPresent(a)) {

			final String message = "A required annotation is missing (@" + a.getSimpleName() + ") in class " + getClass();

			log.error(message);

			throw new DnetGenericException(message);

		}

	}

	@Override

	public void start() {

		log.info("Starting service " + serviceType);

		if (started) {

			log.warn("Service " + this + "already started, check bean initializations!");

		}

		started = true;

	}

	@Override

	public boolean isRunning() {

		log.debug("called isRunning " + this);

		return false;

	}

	@Override

	public void stop() {

		log.info("Stopping service " + this);

	}

	@RequestMapping(value = "", method = RequestMethod.GET)

	public ServiceRunningInstance getStatus() {

		return ServiceRunningInstance.newInstance(profileId, baseUrl, baseDir());

	}

	@RequestMapping(value = "async/response/{id}", method = RequestMethod.POST)

	public final ResponseAck asyncResponse(@PathVariable final String id, @RequestBody final AsyncResponse response) {

		return asyncClientUtils.processResponse(id, response) ? ResponseAck.OK : ResponseAck.IGNORED;

	}

	@RequestMapping(value = "async/method/{method}", method = RequestMethod.POST)

	public final String asyncMethod(@PathVariable final String method, @RequestParam final String caller, @RequestBody final String jsonParams)

			throws DnetGenericException {

		log.info("Starting async method: " + method);

		if (this instanceof HasAsyncMethods) {

			final String id = "invocation-" + UUID.randomUUID();

			final String url = caller + "/async/response/" + id;

			final RestTemplate restTemplate = new RestTemplate();

			new Thread(() -> {

				try {

					((HasAsyncMethods) this).processMethod(method, jsonParams, res -> restTemplate.postForObject(url, res, ResponseAckStatus.class));

				} catch (final Exception e) {

					log.error("Invocation of async method failed", e);

					throw new DnetGenericRuntimeException("Invocation of async method failed", e);

				}

			}).start();

			return id;

		} else {

			log.error("Service " + getServiceType() + " does not implement HasAsyncMethods interface");

			throw new DnetGenericException("Service " + getServiceType() + " does not implement HasAsyncMethods interface");

		}

	}

	protected String baseDir() {

		return containerConfiguration.getBaseDir();

	}

	public String getProfileId() {

		return profileId;

	}

	public void setProfileId(final String profileId) {

		this.profileId = profileId;

	}

	public Map<String, String> getServiceProperties() {

		return serviceProperties;

	}

	public List<Element> geXmlProfileSections() {

		return new ArrayList<>();

	}

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

		this.serviceProperties = serviceProperties;

	}

	public Map<String, String> getExtraProtocols() {

		return extraProtocols;

	}

	public void setExtraProtocols(final Map<String, String> extraProtocols) {

		this.extraProtocols = extraProtocols;

	}

	public DnetServiceType getServiceType() {

		return serviceType;

	}

	public void setServiceType(final DnetServiceType serviceType) {

		this.serviceType = serviceType;

	}

	public String getBaseUrl() {

		return baseUrl;

	}

	public void setBaseUrl(final String baseUrl) {

		this.baseUrl = baseUrl;

	}

}