D-Net

import java.util.Map;

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

import eu.dnetlib.clients.BaseServiceClient;

import eu.dnetlib.services.async.AsyncClientCallback;

import eu.dnetlib.services.async.AsyncClientUtils;

public class MsroClient extends BaseServiceClient {

	@Autowired

	private AsyncClientUtils asyncClientUtils;

	public void startWorkflow(final String wfId, final String parent, final AsyncClientCallback callback) {

		final WorkflowDesc wf = new WorkflowDesc();

		wf.setId(wfId);

		wf.setParent(parent);

		asyncClientUtils.invokeRemoteMethod(getBaseUrl(), "startWorkflow", wf, callback);

	}

	public void startWorkflowTemplate(final String wfTemplateId, final String parent, final Map<String, String> params, final AsyncClientCallback callback) {

		final WorkflowDesc wf = new WorkflowDesc();

		wf.setId(wfTemplateId);

		wf.setParent(parent);

		wf.setTemplate(true);

		wf.setParams(params);

		asyncClientUtils.invokeRemoteMethod(getBaseUrl(), "startWorkflow", wf, callback);

	}

package eu.dnetlib.clients.msro;

import java.util.HashMap;

import java.util.Map;

public class WorkflowDesc {

	private String id;

	private String parent;

	private boolean template = false;

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

	private String family;

	private int priority = 50;

	private String dsId;

	private String iface;

	public String getId() {

		return id;

	}

	public void setId(final String id) {

		this.id = id;

	}

	public String getParent() {

		return parent;

	}

	public void setParent(final String parent) {

		this.parent = parent;

	}

	public boolean isTemplate() {

		return template;

	}

	public void setTemplate(final boolean template) {

		this.template = template;

	}

	public Map<String, String> getParams() {

		return params;

	}

	public void setParams(final Map<String, String> params) {

		this.params = params;

	}

	public String getFamily() {

		return family;

	}

	public void setFamily(final String family) {

		this.family = family;

	}

	public int getPriority() {

		return priority;

	}

	public void setPriority(final int priority) {

		this.priority = priority;

	}

	public String getDsId() {

		return dsId;

	}

	public void setDsId(final String dsId) {

		this.dsId = dsId;

	}

	public String getIface() {

		return iface;

	}

	public void setIface(final String iface) {

		this.iface = iface;

	}

}

package eu.dnetlib.services.hcm;

import java.io.IOException;

import java.lang.management.ManagementFactory;

import java.lang.management.RuntimeMXBean;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import java.util.UUID;

import java.util.stream.Collectors;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.maven.model.Model;

import org.apache.maven.model.Parent;

import org.apache.maven.model.io.xpp3.MavenXpp3Reader;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

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

import org.springframework.core.env.AbstractEnvironment;

import org.springframework.core.env.Environment;

import org.springframework.core.env.MapPropertySource;

import org.springframework.core.env.PropertySource;

import org.springframework.core.io.Resource;

import org.springframework.core.io.ResourceLoader;

import org.springframework.core.io.support.ResourcePatternUtils;

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

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

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

import com.google.common.collect.Maps;

import eu.dnetlib.conf.DnetGenericApplicationProperties;

import eu.dnetlib.enabling.annotations.DnetService;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.miscutils.datetime.HumanTime;

import eu.dnetlib.miscutils.streams.DnetStreamSupport;

import eu.dnetlib.services.BaseService;

@RestController

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

@DnetService(DnetServiceType.hcm)

public class HCM extends BaseService {

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

	@Autowired

	private Environment env;

	@Autowired

	private DnetGenericApplicationProperties containerConfiguration;

	@Autowired

	private ResourceLoader resourceLoader;

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

	public Map<String, Object> listProperties() {

		final Iterator<PropertySource<?>> iter = ((AbstractEnvironment) env).getPropertySources().iterator();

		return DnetStreamSupport.generateStreamFromIterator(iter)

				.filter(ps -> ps instanceof MapPropertySource)

				.map(ps -> (MapPropertySource) ps)

				.collect(Collectors.toMap(MapPropertySource::getName, MapPropertySource::getSource));

	}

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

	public Map<String, Object> info() {

		final RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();

		final Map<String, Object> genInfo = Maps.newLinkedHashMap();

		genInfo.put("Hostname", containerConfiguration.getHost());

		genInfo.put("Port", containerConfiguration.getPort());

		genInfo.put("Uptime", HumanTime.exactly(mxbean.getUptime()));

		genInfo.put("Start Time", DateUtils.calculate_ISO8601(mxbean.getStartTime()));

		return genInfo;

	}

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

	public Map<String, String> jvmInfo() {

		final RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();

		final Map<String, String> jvmInfo = Maps.newLinkedHashMap();

		jvmInfo.put("JVM Name", mxbean.getVmName());

		jvmInfo.put("JVM Vendor", mxbean.getVmVendor());

		jvmInfo.put("JVM Version", mxbean.getVmVersion());

		jvmInfo.put("JVM Spec Name", mxbean.getSpecName());

		jvmInfo.put("JVM Spec Vendor", mxbean.getSpecVendor());

		jvmInfo.put("JVM Spec Version", mxbean.getSpecVersion());

		jvmInfo.put("Running JVM Name", mxbean.getName());

		jvmInfo.put("Management Spec Version", mxbean.getManagementSpecVersion());

		return jvmInfo;

	}

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

	public Map<String, String> libInfo() {

		final RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();

		final Map<String, String> libInfo = Maps.newLinkedHashMap();

		libInfo.put("Classpath", mxbean.getClassPath().replaceAll(":", " : "));

		libInfo.put("Boot ClassPath", mxbean.getBootClassPath().replaceAll(":", " : "));

		libInfo.put("Input arguments", mxbean.getInputArguments().toString());

		libInfo.put("Library Path", mxbean.getLibraryPath().replaceAll(":", " : "));

		return libInfo;

	}

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

	private Map<String, Map<String, Map<String, List<String>>>> mavenModules() throws IOException {

		final Map<String, Map<String, Map<String, List<String>>>> modules = new TreeMap<>();

		final MavenXpp3Reader reader = new MavenXpp3Reader();

		for (final Resource res : ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath*:/META-INF/**/pom.xml")) {

			try {

				final Model model = reader.read(res.getInputStream());

				final String name = model.getArtifactId();

				String groupId = model.getGroupId();

				for (Parent parent = model.getParent(); (groupId == null) && (model.getParent() != null); parent = model.getParent()) {

					groupId = parent.getGroupId();

				}

				String version = model.getVersion();

				for (Parent parent = model.getParent(); (version == null) && (model.getParent() != null); parent = model.getParent()) {

					version = parent.getVersion();

				}

				if (!modules.containsKey(groupId)) {

					modules.put(groupId, new TreeMap<>());

				}

				if (!modules.get(groupId).containsKey(name)) {

					modules.get(groupId).put(name, new TreeMap<>());

				}

				if (!modules.get(groupId).get(name).containsKey(version)) {

					modules.get(groupId).get(name).put(version, new ArrayList<>());

				}

				modules.get(groupId).get(name).get(version).add(res.getURI().toString());

			} catch (final Exception e) {

				log.warn("Error evaluating pom: " + res.getURI());

				log.debug("-- ERROR --", e);

			}

		}

		return modules;

	}

	@Override

	public List<Element> geXmlProfileSections() {

		final Element elem = DocumentHelper.createElement("HCM_SESSION_ID");

		elem.addAttribute("value", "session-" + UUID.randomUUID());

		return Arrays.asList(elem);

	}

}

import java.util.UUID;

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

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

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

import org.springframework.web.client.RestTemplate;

import eu.dnetlib.services.async.AsyncClientUtils;

import eu.dnetlib.services.async.AsyncMethodNotFoundException;

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;

	@Autowired

	private AsyncClientUtils asyncClientUtils;

	@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 clientBaseUrl, @RequestParam final String jsonParams)

			throws DnetGenericException {

		if (this instanceof HasAsyncMethods) {

			try {

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

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

				final RestTemplate restTemplate = new RestTemplate();

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

				return id;

			} catch (final AsyncMethodNotFoundException e) {

				log.error("Async method " + method + " not found");

				throw e;

			}

		} else {

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

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

		}

	}

package eu.dnetlib.services.async;

public interface AsyncServerCallback {

	void notify(AsyncResponse res);

}

package eu.dnetlib.services.async;

public enum AsyncMethodStatus {

	ASSIGNED, SUCCESS, FAILED, RUNNING

}

package eu.dnetlib.services.async;

import java.util.Date;

public abstract class AsyncClientCallback {

	public Date lastInvocation = new Date();

	abstract public void onDone(AsyncResponse res);

	abstract public void onFailed(AsyncResponse res);

	abstract public void onGoing(AsyncResponse res);

	public Date getLastInvocation() {

		return lastInvocation;

	}

	public void setLastInvocation(final Date lastInvocation) {

		this.lastInvocation = lastInvocation;

	}

	public void updateLastInvocation() {

		lastInvocation = new Date();

	}

}

package eu.dnetlib.services.async;

import eu.dnetlib.exceptions.DnetGenericException;

public class AsyncMethodNotFoundException extends DnetGenericException {

	/**

	 *

	 */

	private static final long serialVersionUID = 4505152782783864469L;

	public AsyncMethodNotFoundException() {

		super();

	}

	public AsyncMethodNotFoundException(final String message, final Throwable cause) {

		super(message, cause);

	}

	public AsyncMethodNotFoundException(final String message) {

		super(message);

	}

	public AsyncMethodNotFoundException(final Throwable cause) {

		super(cause);

	}

}

package eu.dnetlib.services.async;

import com.fasterxml.jackson.databind.ObjectMapper;

public class AsyncResponse {

	private String responseJson;

	private AsyncMethodStatus status;

	public AsyncResponse() {}

	public AsyncResponse(final String responseJson, final AsyncMethodStatus status) {

		this.responseJson = responseJson;

		this.status = status;

	}

	public String getResponseJson() {

		return responseJson;

	}

	public void setResponseJson(final String responseJson) {

		this.responseJson = responseJson;

	}

	public AsyncMethodStatus getStatus() {

		return status;

	}

	public void setStatus(final AsyncMethodStatus status) {

		this.status = status;

	}

	public <K> K parseResponse(final Class<K> clazz) throws Exception {

		return (new ObjectMapper()).readValue(responseJson, clazz);

	}

}

package eu.dnetlib.services.async;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

@Component

public class AsyncClientUtils {

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

	private static final Map<String, AsyncClientCallback> activeRemoteCalls = new HashMap<>();

	public void invokeRemoteMethod(final String remoteBaseUrl, final String remoteMethod, final Object o, final AsyncClientCallback callback) {

		final String url = remoteBaseUrl + "/async/method/" + remoteMethod;

		final String id = (new RestTemplate()).postForObject(url, o, String.class);

		activeRemoteCalls.put(id, callback);

	}

	public boolean processResponse(final String id, final AsyncResponse response) {

		if (activeRemoteCalls.containsKey(id)) {

			final AsyncClientCallback callback = activeRemoteCalls.get(id);

			callback.updateLastInvocation();

			switch (response.getStatus()) {

			case ASSIGNED:

			case RUNNING:

				callback.onGoing(response);

				break;

			case SUCCESS:

				callback.onDone(response);

				activeRemoteCalls.remove(id);

				break;

			case FAILED:

				callback.onFailed(response);

				activeRemoteCalls.remove(id);

				break;

			default:

				log.warn("Status " + response.getStatus() + " not managed");

				break;

			}

			return true;

		} else {

			log.warn("Unexpected message: " + id);

			return false;

		}

	}

	public void clearRemoteCalls() {

		activeRemoteCalls.clear();

	}

	public void deleteRemoteCall(final String id) {

		activeRemoteCalls.remove(id);

	}

	public static Map<String, AsyncClientCallback> getActiveremotecalls() {

		return activeRemoteCalls;

	}

}

package eu.dnetlib.services.async;

public interface HasAsyncMethods {

	void processMethod(String method, String jsonParams, AsyncServerCallback callback) throws AsyncMethodNotFoundException;

}

package eu.dnetlib.services.async;

public class ResponseAck {

	public enum ResponseAckStatus {

		OK, IGNORED

	}

	public static final ResponseAck OK = new ResponseAck(ResponseAckStatus.OK);

	public static final ResponseAck IGNORED = new ResponseAck(ResponseAckStatus.IGNORED);

	private ResponseAckStatus status;

	public ResponseAck() {}

	private ResponseAck(final ResponseAckStatus status) {

		this.status = status;

	}

	public ResponseAckStatus getStatus() {

		return status;

	}

	public void setStatus(final ResponseAckStatus status) {

		this.status = status;

	}

}