nlphub/src/main/java/org/gcube/nlphub/legacy/DataminerClient.java

package org.gcube.nlphub.legacy;
//package dataminerclient;

import java.util.List;

import org.gcube.data.analysis.dataminermanagercl.server.DataMinerService;
import org.gcube.data.analysis.dataminermanagercl.server.dmservice.SClient;
import org.gcube.data.analysis.dataminermanagercl.server.monitor.DMMonitor;
import org.gcube.data.analysis.dataminermanagercl.server.monitor.DMMonitorListener;
import org.gcube.data.analysis.dataminermanagercl.shared.data.OutputData;
import org.gcube.data.analysis.dataminermanagercl.shared.data.computations.ComputationId;
import org.gcube.data.analysis.dataminermanagercl.shared.data.output.MapResource;
import org.gcube.data.analysis.dataminermanagercl.shared.data.output.Resource;
import org.gcube.data.analysis.dataminermanagercl.shared.parameters.Parameter;
import org.gcube.data.analysis.dataminermanagercl.shared.process.Operator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DataminerClient {
	private String service, token;
	protected String identifier;
	private static Logger logger = LoggerFactory.getLogger(DataminerClient.class);
	private DataMinerService dataMinerService = null;
	private SClient sClient = null;
	private Operator operator = null;

	public DataminerClient(String service, String identifier, String token) {
		this.service = service;
		this.identifier = identifier;
		this.token = token;
		dataMinerService = new DataMinerService();
	}

	public void init() throws DataminerClientException {
		try {
			sClient = dataMinerService.getClient(getToken(), getService());
			operator = sClient.getOperatorById(getIdentifier());
		} catch (Exception e) {
			logger.error(e.getClass().getName() + ": " + e.getLocalizedMessage());
			throw new DataminerClientException(e.getLocalizedMessage(), e);
		}
	}

	public String getOperatorName() {
		if (operator != null) {
			return operator.getName();
		}
		return "";
	}

	public String getOperatorDescription() {
		if (operator != null) {
			return operator.getDescription();
		}
		return "";
	}

	public String getOperatorBriefDescription() {
		if (operator != null) {
			return operator.getBriefDescription();
		}
		return "";
	}

	public List<Parameter> getOperatorInputParameters() throws DataminerClientException {
		if (operator != null) {
			try {
				return sClient.getInputParameters(operator);
			}
			catch (Exception x) {
				throw new DataminerClientException(x.getLocalizedMessage(), x);
			}
		}
		return null;
	}

	public ComputationId execute(List<Parameter> parameters) throws DataminerClientException {
		try {
			operator.setOperatorParameters(parameters);
			ComputationId computationId = sClient.startComputation(operator);
			monitoringComputation(computationId, sClient);
			return computationId;
		} catch (Exception e) {
			logger.error(e.getClass().getName() + ": " + e.getLocalizedMessage());
			throw new DataminerClientException(e.getLocalizedMessage(), e);
		}
	}

	public String getService() {
		return service;
	}

	public String getIdentifier() {
		return identifier;
	}

	public String getToken() {
		return token;
	}

	public void setIdentifier(String indentifier) {
		this.identifier = identifier;
	}
	
	public void retrieveOutput(ComputationId computationId, SClient sClient) {
		try {
			OutputData output = sClient.getOutputDataByComputationId(computationId);
			// logger.debug("Output: " + output);
			Resource resource = output.getResource();
			if (resource.isMap()) {
				MapResource mapResource = (MapResource) resource;
				for (String key : mapResource.getMap().keySet()) {
					logger.debug("Entry: " + key + " = " + mapResource.getMap().get(key));
					System.out.println("Entry: " + key + " = " + mapResource.getMap().get(key));
				}
			}

		} catch (Exception e) {
			logger.error(e.getLocalizedMessage());
			e.printStackTrace();
		}
	}

	private void monitoringComputation(ComputationId computationId, SClient sClient) {

		DMMonitorListener listener = new DMMonitorListener() {

			@Override
			public void running(double percentage) {
				logger.debug("Operation Running: " + percentage);
			}

			@Override
			public void failed(String message, Exception exception) {
				logger.error("Operation Failed");
				logger.error(message);
				logger.error(exception.getStackTrace().toString());
				System.out.println(exception.getLocalizedMessage());
			}

			@Override
			public void complete(double percentage) {
				logger.debug("Operation Completed");
				logger.debug("Perc: " + percentage);
				retrieveOutput(computationId, sClient);

			}

			@Override
			public void cancelled() {
				logger.debug("Operation Cancelled");
			}

			@Override
			public void accepted() {
				logger.debug("Operation Accepted");

			}
		};

		DMMonitor dmMonitor = new DMMonitor(computationId, sClient);
		dmMonitor.add(listener);
		dmMonitor.start();
	}
/*
	public static void main(String[] args) {
		String service = "http://dataminer-prototypes.d4science.org/wps/";
		String identifier = "";
		identifier = "org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses.transducerers.ENGLISH_NAMED_ENTITY_RECOGNIZER";
		identifier = "org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses.transducerers.NEWSTANBOLWRAPPER";
		//identifier = "org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses.transducerers.GENERIC_OPINION_MINING_ENGLISH";
		String token = "df2cc5f5-63ee-48c1-b2a6-1210030c57b8-843339462";

		DataminerClient dmc = new DataminerClient(service, identifier, token);
		try {
			dmc.init();
			System.out.println(dmc.getOperatorBriefDescription());
			System.out.println(dmc.getOperatorDescription());
			System.out.println(dmc.getOperatorName());
			List<Parameter> parameters = dmc.getOperatorInputParameters();
			if (parameters != null) {
				System.out.println("Parameter number: " + parameters.size());
				for (Parameter p : parameters) {
					System.out.println("name : " + p.getName());
					System.out.println("value: " + p.getValue());
					System.out.println("type : " + p.getTypology());
					System.out.println("desc : " + p.getDescription());
					System.out.println("toString: " + p.toString());
					System.out.println();
				}
			}

			// List<Parameter> parameters = new ArrayList<>();
			//
			// FileParameter fileName = new FileParameter();
			// fileName.setName("inputTextFile");
			// fileName.setValue("http://data.d4science.org/cWRQbHNjRVR4YjdkQXdDUnlSS0JkZVlmLzk2WnJIb1ZHbWJQNStIS0N6Yz0");
			// parameters.add(fileName);
			//
			// ObjectParameter options = new ObjectParameter();
			// options.setName("annotationsList");
			// //options.setValue("Address|Date|Location|Organization|Person|Money|Percent|SpaceToken");
			// options.setValue("SpaceToken");
			// parameters.add(options);
			//
			// ComputationId cid = dmc.execute(parameters);
			// System.out.println("urlId: " + cid.getUrlId());
		} catch (Exception e) {
			System.out.println("-" + e.getClass().getName() + "-\n" + e.getLocalizedMessage());
			e.printStackTrace();
		}
	}
*/
}