taverna-wsdl-activity/src/main/java/net/sf/taverna/t2/activities/wsdl/WSDLActivity.java - incubator-taverna-common-activities - Git at Google

 /*******************************************************************************
  * Copyright (C) 2007 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.t2.activities.wsdl;

 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.SocketTimeoutException;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.wsdl.WSDLException;
 import javax.xml.parsers.ParserConfigurationException;

 import net.sf.taverna.t2.reference.ReferenceService;
 import net.sf.taverna.t2.reference.ReferenceServiceException;
 import net.sf.taverna.t2.reference.T2Reference;
 import net.sf.taverna.t2.security.credentialmanager.CredentialManager;
 import net.sf.taverna.t2.workflowmodel.OutputPort;
 import net.sf.taverna.t2.workflowmodel.health.RemoteHealthChecker;
 import net.sf.taverna.t2.workflowmodel.processor.activity.AbstractAsynchronousActivity;
 import net.sf.taverna.t2.workflowmodel.processor.activity.ActivityConfigurationException;
 import net.sf.taverna.t2.workflowmodel.processor.activity.ActivityOutputPort;
 import net.sf.taverna.t2.workflowmodel.processor.activity.AsynchronousActivityCallback;
 import net.sf.taverna.wsdl.parser.TypeDescriptor;
 import net.sf.taverna.wsdl.parser.UnknownOperationException;
 import net.sf.taverna.wsdl.parser.WSDLParser;

 import org.apache.log4j.Logger;
 import org.xml.sax.SAXException;

 import com.fasterxml.jackson.databind.JsonNode;

 /**
  * An asynchronous Activity that is concerned with WSDL based web-services.
  * <p>
  * The activity is configured according to the WSDL location and the operation.<br>
  * The ports are defined dynamically according to the WSDL specification, and in
  * addition an output<br>
  * port <em>attachmentList</em> is added to represent any attachements that are
  * returned by the webservice.
  * </p>
  *
  * @author Stuart Owen
  * @author Stian Soiland-Reyes
  */
 public class WSDLActivity extends
 		AbstractAsynchronousActivity<JsonNode> implements
 		InputPortTypeDescriptorActivity, OutputPortTypeDescriptorActivity {

 	public static final String URI = "http://ns.taverna.org.uk/2010/activity/wsdl";

 	public static final String ENDPOINT_REFERENCE = "EndpointReference";
 	private JsonNode configurationBean;
 	private WSDLParser parser;
 //	private Map<String, Integer> outputDepth = new HashMap<String, Integer>();
 	private boolean isWsrfService = false;
 //	private String endpointReferenceInputPortName;
 	private CredentialManager credentialManager;

 	public WSDLActivity(CredentialManager credentialManager) {
 		this.credentialManager = credentialManager;
 	}

 	public boolean isWsrfService() {
 		return isWsrfService;
 	}

 	private static Logger logger = Logger.getLogger(WSDLActivity.class);

 	/**
 	 * Configures the activity according to the information passed by the
 	 * configuration bean.<br>
 	 * During this process the WSDL is parsed to determine the input and output
 	 * ports.
 	 *
 	 * @param bean
 	 *            the {@link WSDLActivityConfigurationBean} configuration bean
 	 */
 	@Override
 	public void configure(JsonNode bean)
 			throws ActivityConfigurationException {
 		this.configurationBean = bean;
 		try {
 			parseWSDL();
 		} catch (Exception ex) {
 			throw new ActivityConfigurationException(
 					"Unable to parse the WSDL " + bean.get("operation").get("wsdl").textValue(), ex);
 		}
 	}

 	@Override
 	public JsonNode getConfiguration() {
 		return configurationBean;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @seenet.sf.taverna.t2.activities.wsdl.InputPortTypeDescriptorActivity#
 	 * getTypeDescriptorForInputPort(java.lang.String)
 	 */
 	public TypeDescriptor getTypeDescriptorForInputPort(String portName)
 			throws UnknownOperationException, IOException {
 		List<TypeDescriptor> inputDescriptors = parser
 				.getOperationInputParameters(configurationBean.get("operation").get("name").textValue());
 		TypeDescriptor result = null;
 		for (TypeDescriptor descriptor : inputDescriptors) {
 			if (descriptor.getName().equals(portName)) {
 				result = descriptor;
 				break;
 			}
 		}
 		return result;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @seenet.sf.taverna.t2.activities.wsdl.InputPortTypeDescriptorActivity#
 	 * getTypeDescriptorsForInputPorts()
 	 */
 	public Map<String, TypeDescriptor> getTypeDescriptorsForInputPorts()
 			throws UnknownOperationException, IOException {
 		Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>();
 		List<TypeDescriptor> inputDescriptors = parser
 				.getOperationInputParameters(configurationBean.get("operation").get("name").textValue());
 		for (TypeDescriptor descriptor : inputDescriptors) {
 			descriptors.put(descriptor.getName(), descriptor);
 		}
 		return descriptors;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @seenet.sf.taverna.t2.activities.wsdl.OutputPortTypeDescriptorActivity#
 	 * getTypeDescriptorForOutputPort(java.lang.String)
 	 */
 	public TypeDescriptor getTypeDescriptorForOutputPort(String portName)
 			throws UnknownOperationException, IOException {
 		TypeDescriptor result = null;
 		List<TypeDescriptor> outputDescriptors = parser
 				.getOperationOutputParameters(configurationBean.get("operation").get("name").textValue());
 		for (TypeDescriptor descriptor : outputDescriptors) {
 			if (descriptor.getName().equals(portName)) {
 				result = descriptor;
 				break;
 			}
 		}
 		return result;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @seenet.sf.taverna.t2.activities.wsdl.OutputPortTypeDescriptorActivity#
 	 * getTypeDescriptorsForOutputPorts()
 	 */
 	public Map<String, TypeDescriptor> getTypeDescriptorsForOutputPorts()
 			throws UnknownOperationException, IOException {
 		Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>();
 		List<TypeDescriptor> inputDescriptors = parser
 				.getOperationOutputParameters(configurationBean.get("operation").get("name").textValue());
 		for (TypeDescriptor descriptor : inputDescriptors) {
 			descriptors.put(descriptor.getName(), descriptor);
 		}
 		return descriptors;
 	}

 	private void parseWSDL() throws ParserConfigurationException,
 			WSDLException, IOException, SAXException, UnknownOperationException {
 		String wsdlLocation = configurationBean.get("operation").get("wsdl").textValue();
 		URLConnection connection = null;
 		try {
 			URL wsdlURL = new URL(wsdlLocation);
 			connection = wsdlURL.openConnection();
 			connection.setConnectTimeout(RemoteHealthChecker.getTimeoutInSeconds() * 1000);
 			connection.connect();
 		} catch (MalformedURLException e) {
 			throw new IOException("Malformed URL", e);
 		} catch (SocketTimeoutException e) {
 			throw new IOException("Timeout", e);
 		} catch (IOException e) {
 			throw e;
 		} finally {
 			if ((connection != null) && (connection.getInputStream() != null)) {
 				connection.getInputStream().close();
 			}
 		}
 		parser = new WSDLParser(wsdlLocation);
 		isWsrfService = parser.isWsrfService();
 	}

 	@Override
 	public void executeAsynch(final Map<String, T2Reference> data,
 			final AsynchronousActivityCallback callback) {

 		callback.requestRun(new Runnable() {

 			public void run() {

 				ReferenceService referenceService = callback.getContext()
 						.getReferenceService();

 				Map<String, T2Reference> outputData = new HashMap<String, T2Reference>();
 				Map<String, Object> invokerInputMap = new HashMap<String, Object>();
 				String endpointReferenceInputPortName = getEndpointReferenceInputPortName();

 				try {
 					String endpointReference = null;
 					for (String key : data.keySet()) {
 						Object renderIdentifier = referenceService
 								.renderIdentifier(data.get(key), String.class,
 										callback.getContext());
 						if (isWsrfService()
 								&& key.equals(endpointReferenceInputPortName)) {
 							endpointReference = (String) renderIdentifier;
 						} else {
 							invokerInputMap.put(key, renderIdentifier);
 						}
 					}
 					List<String> outputNames = new ArrayList<String>();
 					for (OutputPort port : getOutputPorts()) {
 						outputNames.add(port.getName());
 					}

 					T2WSDLSOAPInvoker invoker = new T2WSDLSOAPInvoker(parser,
 							configurationBean.get("operation").get("name").textValue(), outputNames,
 							endpointReference, credentialManager);

 					Map<String, Object> invokerOutputMap = invoker.invoke(
 							invokerInputMap, configurationBean);

 					for (String outputName : invokerOutputMap.keySet()) {
 					    Object value = invokerOutputMap.get(outputName);

 						if (value != null) {
 							Integer depth = getOutputPortDepth(outputName);
 							if (depth != null) {
 								outputData.put(outputName, referenceService
 										.register(value, depth, true, callback
 												.getContext()));
 							} else {
 								logger.info("Skipping unknown output port :"
 												+ outputName);
 //								// TODO what should the depth be in this case?
 //								outputData.put(outputName, referenceService
 //										.register(value, 0, true, callback
 //												.getContext()));
 							}
 						}
 					}
 					callback.receiveResult(outputData, new int[0]);
 				} catch (ReferenceServiceException e) {
 					logger.error("Error finding the input data for "
 							+ getConfiguration().get("operation"), e);
 					callback.fail("Unable to find input data", e);
 					return;
 				} catch (Exception e) {
 					logger.error("Error invoking WSDL service "
 							+ getConfiguration().get("operation"), e);
 					callback.fail(
 							"An error occurred invoking the WSDL service", e);
 					return;
 				}

 			}

 		});

 	}

 	private Integer getOutputPortDepth(String portName) {
 		for (ActivityOutputPort outputPort : getOutputPorts()) {
 			if (outputPort.getName().equals(portName)) {
 				return outputPort.getDepth();
 			}
 		}
 		return null;
 	}

 	private String getEndpointReferenceInputPortName() {
 		String endpointReferenceInputPortName = null;
 		if (parser.isWsrfService()) {
 			Set<String> inputPorts = new HashSet<>();
 			try {
 				List<TypeDescriptor> inputDescriptors = parser.getOperationInputParameters(configurationBean
 						.get("operation").get("name").textValue());
 				for (TypeDescriptor descriptor : inputDescriptors) {
 					inputPorts.add(descriptor.getName());
 				}
 			} catch (UnknownOperationException | IOException e) {
 			}
 			// Make sure the port name is unique
 			endpointReferenceInputPortName = WSDLActivity.ENDPOINT_REFERENCE;
 			int counter = 0;
 			while (inputPorts.contains(endpointReferenceInputPortName)) {
 				endpointReferenceInputPortName = WSDLActivity.ENDPOINT_REFERENCE + counter++;
 			}
 		}
 		return endpointReferenceInputPortName;
 	}

 }
	/*******************************************************************************
	* Copyright (C) 2007 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.t2.activities.wsdl;

	import java.io.IOException;
	import java.net.MalformedURLException;
	import java.net.SocketTimeoutException;
	import java.net.URL;
	import java.net.URLConnection;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import javax.wsdl.WSDLException;
	import javax.xml.parsers.ParserConfigurationException;

	import net.sf.taverna.t2.reference.ReferenceService;
	import net.sf.taverna.t2.reference.ReferenceServiceException;
	import net.sf.taverna.t2.reference.T2Reference;
	import net.sf.taverna.t2.security.credentialmanager.CredentialManager;
	import net.sf.taverna.t2.workflowmodel.OutputPort;
	import net.sf.taverna.t2.workflowmodel.health.RemoteHealthChecker;
	import net.sf.taverna.t2.workflowmodel.processor.activity.AbstractAsynchronousActivity;
	import net.sf.taverna.t2.workflowmodel.processor.activity.ActivityConfigurationException;
	import net.sf.taverna.t2.workflowmodel.processor.activity.ActivityOutputPort;
	import net.sf.taverna.t2.workflowmodel.processor.activity.AsynchronousActivityCallback;
	import net.sf.taverna.wsdl.parser.TypeDescriptor;
	import net.sf.taverna.wsdl.parser.UnknownOperationException;
	import net.sf.taverna.wsdl.parser.WSDLParser;

	import org.apache.log4j.Logger;
	import org.xml.sax.SAXException;

	import com.fasterxml.jackson.databind.JsonNode;

	/**
	* An asynchronous Activity that is concerned with WSDL based web-services.
	* <p>
	* The activity is configured according to the WSDL location and the operation.<br>
	* The ports are defined dynamically according to the WSDL specification, and in
	* addition an output<br>
	* port <em>attachmentList</em> is added to represent any attachements that are
	* returned by the webservice.
	* </p>
	*
	* @author Stuart Owen
	* @author Stian Soiland-Reyes
	*/
	public class WSDLActivity extends
	AbstractAsynchronousActivity<JsonNode> implements
	InputPortTypeDescriptorActivity, OutputPortTypeDescriptorActivity {

	public static final String URI = "http://ns.taverna.org.uk/2010/activity/wsdl";

	public static final String ENDPOINT_REFERENCE = "EndpointReference";
	private JsonNode configurationBean;
	private WSDLParser parser;
	// private Map<String, Integer> outputDepth = new HashMap<String, Integer>();
	private boolean isWsrfService = false;
	// private String endpointReferenceInputPortName;
	private CredentialManager credentialManager;

	public WSDLActivity(CredentialManager credentialManager) {
	this.credentialManager = credentialManager;
	}

	public boolean isWsrfService() {
	return isWsrfService;
	}

	private static Logger logger = Logger.getLogger(WSDLActivity.class);

	/**
	* Configures the activity according to the information passed by the
	* configuration bean.<br>
	* During this process the WSDL is parsed to determine the input and output
	* ports.
	*
	* @param bean
	* the {@link WSDLActivityConfigurationBean} configuration bean
	*/
	@Override
	public void configure(JsonNode bean)
	throws ActivityConfigurationException {
	this.configurationBean = bean;
	try {
	parseWSDL();
	} catch (Exception ex) {
	throw new ActivityConfigurationException(
	"Unable to parse the WSDL " + bean.get("operation").get("wsdl").textValue(), ex);
	}
	}

	@Override
	public JsonNode getConfiguration() {
	return configurationBean;
	}

	/*
	* (non-Javadoc)
	*
	* @seenet.sf.taverna.t2.activities.wsdl.InputPortTypeDescriptorActivity#
	* getTypeDescriptorForInputPort(java.lang.String)
	*/
	public TypeDescriptor getTypeDescriptorForInputPort(String portName)
	throws UnknownOperationException, IOException {
	List<TypeDescriptor> inputDescriptors = parser
	.getOperationInputParameters(configurationBean.get("operation").get("name").textValue());
	TypeDescriptor result = null;
	for (TypeDescriptor descriptor : inputDescriptors) {
	if (descriptor.getName().equals(portName)) {
	result = descriptor;
	break;
	}
	}
	return result;
	}

	/*
	* (non-Javadoc)
	*
	* @seenet.sf.taverna.t2.activities.wsdl.InputPortTypeDescriptorActivity#
	* getTypeDescriptorsForInputPorts()
	*/
	public Map<String, TypeDescriptor> getTypeDescriptorsForInputPorts()
	throws UnknownOperationException, IOException {
	Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>();
	List<TypeDescriptor> inputDescriptors = parser
	.getOperationInputParameters(configurationBean.get("operation").get("name").textValue());
	for (TypeDescriptor descriptor : inputDescriptors) {
	descriptors.put(descriptor.getName(), descriptor);
	}
	return descriptors;
	}

	/*
	* (non-Javadoc)
	*
	* @seenet.sf.taverna.t2.activities.wsdl.OutputPortTypeDescriptorActivity#
	* getTypeDescriptorForOutputPort(java.lang.String)
	*/
	public TypeDescriptor getTypeDescriptorForOutputPort(String portName)
	throws UnknownOperationException, IOException {
	TypeDescriptor result = null;
	List<TypeDescriptor> outputDescriptors = parser
	.getOperationOutputParameters(configurationBean.get("operation").get("name").textValue());
	for (TypeDescriptor descriptor : outputDescriptors) {
	if (descriptor.getName().equals(portName)) {
	result = descriptor;
	break;
	}
	}
	return result;
	}

	/*
	* (non-Javadoc)
	*
	* @seenet.sf.taverna.t2.activities.wsdl.OutputPortTypeDescriptorActivity#
	* getTypeDescriptorsForOutputPorts()
	*/
	public Map<String, TypeDescriptor> getTypeDescriptorsForOutputPorts()
	throws UnknownOperationException, IOException {
	Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>();
	List<TypeDescriptor> inputDescriptors = parser
	.getOperationOutputParameters(configurationBean.get("operation").get("name").textValue());
	for (TypeDescriptor descriptor : inputDescriptors) {
	descriptors.put(descriptor.getName(), descriptor);
	}
	return descriptors;
	}

	private void parseWSDL() throws ParserConfigurationException,
	WSDLException, IOException, SAXException, UnknownOperationException {
	String wsdlLocation = configurationBean.get("operation").get("wsdl").textValue();
	URLConnection connection = null;
	try {
	URL wsdlURL = new URL(wsdlLocation);
	connection = wsdlURL.openConnection();
	connection.setConnectTimeout(RemoteHealthChecker.getTimeoutInSeconds() * 1000);
	connection.connect();
	} catch (MalformedURLException e) {
	throw new IOException("Malformed URL", e);
	} catch (SocketTimeoutException e) {
	throw new IOException("Timeout", e);
	} catch (IOException e) {
	throw e;
	} finally {
	if ((connection != null) && (connection.getInputStream() != null)) {
	connection.getInputStream().close();
	}
	}
	parser = new WSDLParser(wsdlLocation);
	isWsrfService = parser.isWsrfService();
	}

	@Override
	public void executeAsynch(final Map<String, T2Reference> data,
	final AsynchronousActivityCallback callback) {

	callback.requestRun(new Runnable() {

	public void run() {

	ReferenceService referenceService = callback.getContext()
	.getReferenceService();

	Map<String, T2Reference> outputData = new HashMap<String, T2Reference>();
	Map<String, Object> invokerInputMap = new HashMap<String, Object>();
	String endpointReferenceInputPortName = getEndpointReferenceInputPortName();

	try {
	String endpointReference = null;
	for (String key : data.keySet()) {
	Object renderIdentifier = referenceService
	.renderIdentifier(data.get(key), String.class,
	callback.getContext());
	if (isWsrfService()
	&& key.equals(endpointReferenceInputPortName)) {
	endpointReference = (String) renderIdentifier;
	} else {
	invokerInputMap.put(key, renderIdentifier);
	}
	}
	List<String> outputNames = new ArrayList<String>();
	for (OutputPort port : getOutputPorts()) {
	outputNames.add(port.getName());
	}

	T2WSDLSOAPInvoker invoker = new T2WSDLSOAPInvoker(parser,
	configurationBean.get("operation").get("name").textValue(), outputNames,
	endpointReference, credentialManager);

	Map<String, Object> invokerOutputMap = invoker.invoke(
	invokerInputMap, configurationBean);

	for (String outputName : invokerOutputMap.keySet()) {
	Object value = invokerOutputMap.get(outputName);

	if (value != null) {
	Integer depth = getOutputPortDepth(outputName);
	if (depth != null) {
	outputData.put(outputName, referenceService
	.register(value, depth, true, callback
	.getContext()));
	} else {
	logger.info("Skipping unknown output port :"
	+ outputName);
	// // TODO what should the depth be in this case?
	// outputData.put(outputName, referenceService
	// .register(value, 0, true, callback
	// .getContext()));
	}
	}
	}
	callback.receiveResult(outputData, new int[0]);
	} catch (ReferenceServiceException e) {
	logger.error("Error finding the input data for "
	+ getConfiguration().get("operation"), e);
	callback.fail("Unable to find input data", e);
	return;
	} catch (Exception e) {
	logger.error("Error invoking WSDL service "
	+ getConfiguration().get("operation"), e);
	callback.fail(
	"An error occurred invoking the WSDL service", e);
	return;
	}

	}

	});

	}

	private Integer getOutputPortDepth(String portName) {
	for (ActivityOutputPort outputPort : getOutputPorts()) {
	if (outputPort.getName().equals(portName)) {
	return outputPort.getDepth();
	}
	}
	return null;
	}

	private String getEndpointReferenceInputPortName() {
	String endpointReferenceInputPortName = null;
	if (parser.isWsrfService()) {
	Set<String> inputPorts = new HashSet<>();
	try {
	List<TypeDescriptor> inputDescriptors = parser.getOperationInputParameters(configurationBean
	.get("operation").get("name").textValue());
	for (TypeDescriptor descriptor : inputDescriptors) {
	inputPorts.add(descriptor.getName());
	}
	} catch (UnknownOperationException \| IOException e) {
	}
	// Make sure the port name is unique
	endpointReferenceInputPortName = WSDLActivity.ENDPOINT_REFERENCE;
	int counter = 0;
	while (inputPorts.contains(endpointReferenceInputPortName)) {
	endpointReferenceInputPortName = WSDLActivity.ENDPOINT_REFERENCE + counter++;
	}
	}
	return endpointReferenceInputPortName;
	}

	}