878 lines
38 KiB
Java
878 lines
38 KiB
Java
/*
|
|
* BEGIN_HEADER - DO NOT EDIT
|
|
*
|
|
* The contents of this file are subject to the terms
|
|
* of the Common Development and Distribution License
|
|
* (the "License"). You may not use this file except
|
|
* in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at
|
|
* https://open-jbi-components.dev.java.net/public/CDDLv1.0.html.
|
|
* See the License for the specific language governing
|
|
* permissions and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL
|
|
* HEADER in each file and include the License file at
|
|
* https://open-jbi-components.dev.java.net/public/CDDLv1.0.html.
|
|
* If applicable add the following below this CDDL HEADER,
|
|
* with the fields enclosed by brackets "[]" replaced with
|
|
* your own identifying information: Portions Copyright
|
|
* [year] [name of copyright owner]
|
|
*/
|
|
|
|
package com.sun.jbi.imsbc.packaging;
|
|
|
|
import java.io.File;
|
|
|
|
import java.net.URL;
|
|
|
|
import java.util.Map;
|
|
import java.util.List;
|
|
import java.util.HashMap;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.Collection;
|
|
|
|
import java.util.logging.Logger;
|
|
import java.util.logging.Level;
|
|
|
|
import javax.wsdl.Port;
|
|
import javax.wsdl.Part;
|
|
import javax.wsdl.Input;
|
|
import javax.wsdl.Output;
|
|
import javax.wsdl.Binding;
|
|
import javax.wsdl.Operation;
|
|
import javax.wsdl.Definition;
|
|
import javax.wsdl.OperationType;
|
|
import javax.wsdl.BindingInput;
|
|
import javax.wsdl.BindingOutput;
|
|
import javax.wsdl.BindingOperation;
|
|
import javax.wsdl.WSDLException;
|
|
|
|
import javax.wsdl.Service;
|
|
import javax.wsdl.PortType;
|
|
import javax.wsdl.extensions.ExtensibilityElement;
|
|
import javax.wsdl.factory.WSDLFactory;
|
|
import javax.wsdl.xml.WSDLReader;
|
|
|
|
import javax.xml.namespace.QName;
|
|
import javax.xml.parsers.DocumentBuilder;
|
|
import javax.xml.parsers.DocumentBuilderFactory;
|
|
|
|
import org.xml.sax.EntityResolver;
|
|
|
|
|
|
import org.w3c.dom.Document;
|
|
|
|
import com.sun.jbi.internationalization.Messages;
|
|
|
|
import com.ibm.wsdl.factory.WSDLFactoryImpl;
|
|
|
|
import com.sun.xsd.model.FastSchemaFactory;
|
|
import com.sun.xsd.model.FastSchema;
|
|
|
|
import com.sun.encoder.MetaRef;
|
|
import com.sun.encoder.Encoder;
|
|
import com.sun.encoder.EncoderFactory;
|
|
|
|
import com.sun.jbi.imsbc.Endpoint;
|
|
import com.sun.jbi.imsbc.EndpointImpl;
|
|
import com.sun.jbi.imsbc.Endpoint.EndpointType;
|
|
import com.sun.jbi.imsbc.Endpoint.EndpointState;
|
|
import com.sun.jbi.imsbc.Endpoint.EndpointMessageType;
|
|
import com.sun.jbi.imsbc.extensions.IMSInput;
|
|
import com.sun.jbi.imsbc.extensions.IMSOutput;
|
|
import com.sun.jbi.imsbc.extensions.IMSMessage;
|
|
import com.sun.jbi.imsbc.extensions.IMSAddress;
|
|
import com.sun.jbi.imsbc.extensions.IMSBinding;
|
|
import com.sun.jbi.imsbc.extensions.IMSOperation;
|
|
import com.sun.jbi.imsbc.extensions.IMSExtensionRegistry;
|
|
import com.sun.jbi.imsbc.extensions.IMSExtPreprocessDeserializer;
|
|
import com.sun.jbi.imsbc.mbeans.ApplicationConfigurationField;
|
|
import com.sun.jbi.imsbc.mbeans.AppConfigAddressVisitor;
|
|
import com.sun.jbi.imsbc.mbeans.Visitor;
|
|
|
|
import org.apache.xml.resolver.CatalogManager;
|
|
import org.apache.xml.resolver.tools.CatalogResolver;
|
|
|
|
/**
|
|
* WSDLConfiguration maps a list of WSDL files to the list of Endpoints based on the portmap list.
|
|
*
|
|
* @author Sun Microsystems
|
|
*/
|
|
public class WSDLConfigurations {
|
|
|
|
private static Logger mLogger = Messages.getLogger(WSDLConfigurations.class);
|
|
|
|
private static final Messages mMessages = Messages.getMessages(WSDLConfigurations.class);
|
|
|
|
private final File mRootPath;
|
|
|
|
private List mXsds = new ArrayList();
|
|
|
|
private Map mEncoderMap = new HashMap();
|
|
|
|
public WSDLConfigurations(String rootPath) {
|
|
mRootPath = new File(rootPath);
|
|
}
|
|
|
|
public Collection<Endpoint> createEndpoints(
|
|
Collection portMaps,
|
|
Map<String, String[]> envVariableMap,
|
|
Map<String, Collection<ApplicationConfigurationField>> appConfMap)
|
|
throws Exception {
|
|
|
|
File catalog = new File(mRootPath.getAbsolutePath() +
|
|
File.separator + "META-INF" + File.separator +
|
|
"catalog.xml");
|
|
|
|
EntityResolver resolver = null;
|
|
|
|
if (catalog.exists()) {
|
|
CatalogManager catalogManager = new CatalogManager();
|
|
catalogManager.setCatalogFiles(catalog.getAbsolutePath());
|
|
catalogManager.setRelativeCatalogs(true);
|
|
resolver = new CatalogResolver(catalogManager);
|
|
}
|
|
|
|
ArrayList<Endpoint> endpoints = new ArrayList<Endpoint>();
|
|
List<File> wsdLs = listResourceFiles(mRootPath, ".wsdl");
|
|
for (File file : wsdLs) {
|
|
endpoints.addAll(
|
|
parseWSDL(file,
|
|
resolver,
|
|
portMaps,
|
|
envVariableMap,
|
|
appConfMap));
|
|
}
|
|
|
|
return endpoints;
|
|
}
|
|
|
|
public Map<String, String[]> parseForEnvironmentVariables(List portMaps, Map<String, String[]> envVariableMap) throws Exception {
|
|
Map<String, String[]> envVariables =
|
|
new HashMap<String, String[]>(envVariableMap);
|
|
|
|
File catalog = new File(mRootPath.getAbsolutePath() +
|
|
File.separator + "META-INF" + File.separator +
|
|
"catalog.xml");
|
|
|
|
EntityResolver resolver = null;
|
|
|
|
if ( catalog.exists() ) {
|
|
CatalogManager catalogManager = new CatalogManager();
|
|
catalogManager.setCatalogFiles(catalog.getAbsolutePath());
|
|
catalogManager.setRelativeCatalogs(true);
|
|
catalogManager.setUseStaticCatalog(false);
|
|
resolver = new CatalogResolver(catalogManager);
|
|
}
|
|
|
|
for (File file : listResourceFiles(mRootPath, ".wsdl")) {
|
|
envVariables.putAll(
|
|
readWSDLForEnvVariables(file,
|
|
resolver,
|
|
envVariables));
|
|
}
|
|
|
|
return envVariables;
|
|
}
|
|
|
|
|
|
protected Definition readWSDL(File f, EntityResolver resolver, Map envVariableMap) throws WSDLException {
|
|
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
WSDLReader reader = ((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
reader.setExtensionRegistry(new IMSExtensionRegistry(envVariableMap));
|
|
Definition def = reader.readWSDL(f.getAbsolutePath());
|
|
|
|
return def;
|
|
}
|
|
|
|
private Map readWSDLForEnvVariables(File f, EntityResolver resolver, Map<String, String[]> envVariableMap)
|
|
throws WSDLException {
|
|
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
WSDLReader reader = resolver == null ? ((WSDLFactoryImpl) wsdlFactory).newWSDLReader() :
|
|
((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
IMSExtPreprocessDeserializer preProcessDeserializer = new IMSExtPreprocessDeserializer(envVariableMap);
|
|
reader.setExtensionRegistry(new IMSExtensionRegistry(preProcessDeserializer));
|
|
reader.readWSDL(f.getAbsolutePath());
|
|
return preProcessDeserializer.getEnvVariableMap();
|
|
}
|
|
|
|
public List parseWSDL(File wsdlFile, EntityResolver resolver,
|
|
Collection portMaps, Map<String, String[]> envVariableMap,
|
|
Map<String, Collection<ApplicationConfigurationField>> appConfMap)
|
|
throws Exception {
|
|
|
|
Definition def = readWSDL(wsdlFile, resolver, envVariableMap);
|
|
ArrayList endPoints = new ArrayList();
|
|
Iterator it = portMaps.iterator();
|
|
while (it.hasNext()) {
|
|
EndpointData pm = (EndpointData) it.next();
|
|
|
|
// Check the Definition if it has a IMSBinding. If not,
|
|
// continue
|
|
IMSBinding binding = getIMSBinding(def, pm.getService(), pm.getEndpoint());
|
|
if (binding == null) {
|
|
continue;
|
|
}
|
|
|
|
// look through all the definitions to see if we can find a
|
|
// service binding that matches this endpoint. If we find one,
|
|
// extract file details
|
|
|
|
// If we have a IMSBinding, we must have an IMSAddress.
|
|
IMSAddress address = getIMSAddress(def, pm.getService(), pm.getEndpoint());
|
|
if (address == null) {
|
|
String msg = mMessages.getString("IMSBC-E00910.Missing_Ims_Address") + pm.getService();
|
|
throw new Exception(msg);
|
|
}
|
|
|
|
// if an application configuration object is defined for this
|
|
// endpoint, apply it.
|
|
String appConfName = pm.getApplicationConfigurationObjectName();
|
|
Collection<ApplicationConfigurationField> appConfObj = appConfMap.get(appConfName);
|
|
if (appConfObj != null) {
|
|
applyApplicationConfiguration(address, appConfObj);
|
|
}
|
|
|
|
// If we have an IMSBinding, we must have operations
|
|
Map imsOperations = getIMSOperations(def, pm.getService(), pm.getEndpoint(), pm.getDirection());
|
|
if (imsOperations == null || imsOperations.size() == 0) {
|
|
String msg = mMessages.getString("IMSBC-E00911.Missing_Ims_Operation_Definition") + pm.getService();
|
|
throw new Exception(msg);
|
|
}
|
|
|
|
Map opMsgExchangePatterns = getIMSOperationMepTypes(def, pm.getService(), pm.getEndpoint(),
|
|
pm.getDirection());
|
|
|
|
// Create an Endpoint for each Port. The endpoint should have the
|
|
// correct IMSBinding, the associated Operations, and the
|
|
// associated OperationInput and OperationOutput
|
|
Endpoint endpoint = new EndpointImpl();
|
|
|
|
// Store the endpoint name
|
|
endpoint.setEndpointName(pm.getEndpoint());
|
|
|
|
// Store the Service name
|
|
endpoint.setServiceName(QName.valueOf(pm.getService()));
|
|
|
|
// Store the Definition
|
|
endpoint.setDefinition(def);
|
|
|
|
// Store the type of Endpoint
|
|
endpoint.setEndpointType(pm.getDirection());
|
|
|
|
// Set the description
|
|
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
|
|
DocumentBuilder documentBuilder = docBuilderFactory.newDocumentBuilder();
|
|
Document result = documentBuilder.parse(wsdlFile);
|
|
endpoint.setServiceDescription(result);
|
|
|
|
// Store our extensibility elements
|
|
endpoint.setIMSAddress(address);
|
|
endpoint.setIMSBinding(binding);
|
|
endpoint.setIMSOperations(imsOperations);
|
|
endpoint.setOperationMsgExchangePatterns(opMsgExchangePatterns);
|
|
|
|
setInputsOutputs(def, pm.getService(), pm.getEndpoint(), imsOperations.values(), endpoint);
|
|
|
|
// Now add the Endpoint to our list of Endpoints
|
|
endPoints.add(endpoint);
|
|
}
|
|
|
|
return endPoints;
|
|
}
|
|
|
|
/**
|
|
* Applies the configuration values represented by an application
|
|
* configuration object, to an IMSBCAddress object.
|
|
*
|
|
* @param address The IMSBCAddress to which to apply the configuration
|
|
* @param appConfObj The application configuration object to apply
|
|
*/
|
|
private void applyApplicationConfiguration(IMSAddress address,
|
|
Collection<ApplicationConfigurationField> appConfObj) {
|
|
assert address != null;
|
|
assert appConfObj != null;
|
|
if (!appConfObj.isEmpty()) {
|
|
Visitor addressVisitor = new AppConfigAddressVisitor(address);
|
|
for (ApplicationConfigurationField field: appConfObj) {
|
|
field.accept(addressVisitor);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* List all wsdl files in the currentDir and below
|
|
*/
|
|
protected List<File> listResourceFiles(File currentDir, String extension) {
|
|
List<File> cumulativeResults = new ArrayList();
|
|
File[] filesInCurrentDir = currentDir.listFiles();
|
|
for (int fileCount = 0; fileCount < filesInCurrentDir.length; fileCount++) {
|
|
|
|
if (filesInCurrentDir[fileCount].isFile()) {
|
|
if (filesInCurrentDir[fileCount].getName().toLowerCase().endsWith(extension)) {
|
|
cumulativeResults.add(filesInCurrentDir[fileCount]);
|
|
}
|
|
} else if (filesInCurrentDir[fileCount].isDirectory()) {
|
|
List wsdlsInSubDirectories = listResourceFiles(filesInCurrentDir[fileCount], extension);
|
|
cumulativeResults.addAll(wsdlsInSubDirectories);
|
|
}
|
|
}
|
|
return cumulativeResults;
|
|
}
|
|
|
|
/* protected Definition readWSDL(File f, EntityResolver resolver) throws javax.wsdl.WSDLException {
|
|
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
|
|
WSDLReader reader = ((WSDLFactoryImpl) wsdlFactory).newWSDLReader(resolver);
|
|
reader.setExtensionRegistry(new IMSExtensionRegistry());
|
|
Definition def = reader.readWSDL(f.getAbsolutePath());
|
|
|
|
return def;
|
|
}*/
|
|
|
|
protected Binding getBinding(Definition def, String serviceName, String endpointName) {
|
|
String location = null;
|
|
Service svc = def.getService(QName.valueOf(serviceName));
|
|
if (svc == null) {
|
|
return null;
|
|
}
|
|
Port port = svc.getPort(QName.valueOf(endpointName).getLocalPart());
|
|
if (port == null) {
|
|
return null;
|
|
} else {
|
|
return port.getBinding();
|
|
}
|
|
}
|
|
|
|
protected IMSAddress getIMSAddress(Definition def, String serviceName, String endpointName) {
|
|
IMSAddress address = null;
|
|
Service svc = def.getService(QName.valueOf(serviceName));
|
|
if (svc == null) {
|
|
return null;
|
|
}
|
|
Port port = svc.getPort(QName.valueOf(endpointName).getLocalPart());
|
|
if (port != null) {
|
|
List extElems = port.getExtensibilityElements();
|
|
|
|
// Look for ims:address
|
|
|
|
Iterator extIter = extElems == null ? null : extElems.iterator();
|
|
while (extIter != null && extIter.hasNext() && address == null) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
if (IMSAddress.class.isInstance(ee)) {
|
|
address = (IMSAddress) ee;
|
|
}
|
|
}
|
|
}
|
|
return address;
|
|
}
|
|
|
|
protected IMSBinding getIMSBinding(Definition def, String serviceName, String endpointName) {
|
|
IMSBinding imsBinding = null;
|
|
Binding binding = getBinding(def, serviceName, endpointName);
|
|
if (binding != null) {
|
|
List extElems = binding.getExtensibilityElements();
|
|
|
|
// Look for ims:binding
|
|
|
|
Iterator extIter = extElems == null ? null : extElems.iterator();
|
|
while (extIter != null && extIter.hasNext() && imsBinding == null) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
if (IMSBinding.class.isInstance(ee)) {
|
|
imsBinding = (IMSBinding) ee;
|
|
}
|
|
}
|
|
}
|
|
return imsBinding;
|
|
}
|
|
|
|
protected Map getIMSOperations(Definition def, String serviceName, String endpointName, int isInbound) {
|
|
Map imsOperations = new HashMap();
|
|
Binding binding = getBinding(def, serviceName, endpointName);
|
|
if (binding != null) {
|
|
List bindingOperations = binding.getBindingOperations();
|
|
|
|
// Look for ims:operation
|
|
|
|
Iterator operIter = bindingOperations == null ? null : bindingOperations.iterator();
|
|
while (operIter != null && operIter.hasNext()) {
|
|
BindingOperation oper = (BindingOperation) operIter.next();
|
|
List extElems = oper.getExtensibilityElements();
|
|
Iterator extIter = extElems == null ? null : extElems.iterator();
|
|
while (extIter != null && extIter.hasNext()) {
|
|
ExtensibilityElement operExt = (ExtensibilityElement) extIter.next();
|
|
if (IMSOperation.class.isInstance(operExt)) {
|
|
IMSOperation imsOperation = (IMSOperation) operExt;
|
|
imsOperation.setBindingOperation(oper);
|
|
imsOperation.setMEP(determineMEP(isInbound, oper));
|
|
BindingInput bindingInput = oper.getBindingInput();
|
|
if (bindingInput != null) {
|
|
Iterator inputIter = bindingInput.getExtensibilityElements().iterator();
|
|
while (inputIter.hasNext()) {
|
|
ExtensibilityElement inputExt = (ExtensibilityElement) inputIter.next();
|
|
IMSInput imsInput = null;
|
|
if (inputExt instanceof IMSMessage) {
|
|
imsInput = new IMSInput();
|
|
IMSMessage imsMessage = (IMSMessage) inputExt;
|
|
imsInput.setImsMessage(imsMessage);
|
|
}
|
|
if (imsInput != null) {
|
|
imsOperation.setIMSOperationInput(imsInput);
|
|
}
|
|
}
|
|
}
|
|
|
|
BindingOutput bindingOutput = oper.getBindingOutput();
|
|
if (bindingOutput != null) {
|
|
Iterator outputIter = bindingOutput.getExtensibilityElements().iterator();
|
|
while (outputIter.hasNext()) {
|
|
ExtensibilityElement outputExt = (ExtensibilityElement) outputIter.next();
|
|
IMSOutput imsOutput = null;
|
|
if (outputExt instanceof IMSMessage) {
|
|
imsOutput = new IMSOutput();
|
|
IMSMessage imsMessage = (IMSMessage) outputExt;
|
|
imsOutput.setImsMessage(imsMessage);
|
|
}
|
|
|
|
if (imsOutput != null) {
|
|
imsOperation.setIMSOperationOutput(imsOutput);
|
|
}
|
|
}
|
|
}
|
|
imsOperations.put(QName.valueOf(oper.getName()), imsOperation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return imsOperations;
|
|
}
|
|
|
|
protected void setInputsOutputs(Definition def,
|
|
String serviceName,
|
|
String endpointName,
|
|
Collection operations,
|
|
Endpoint endpoint) {
|
|
|
|
Binding binding = getBinding(def, serviceName, endpointName);
|
|
if (binding != null) {
|
|
List bindingOperations = binding.getBindingOperations();
|
|
Iterator operIter = bindingOperations == null ? null : bindingOperations.iterator();
|
|
while (operIter != null && operIter.hasNext()) {
|
|
BindingOperation oper = (BindingOperation) operIter.next();
|
|
List extElems = oper.getExtensibilityElements();
|
|
|
|
// Look for ims:operation entries
|
|
IMSOperation imsOperation = null;
|
|
Iterator extIter = extElems == null ? null : extElems.iterator();
|
|
while (extIter != null && extIter.hasNext()) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
if (operations.contains(ee)) {
|
|
imsOperation = (IMSOperation) ee;
|
|
}
|
|
}
|
|
|
|
if (imsOperation != null) {
|
|
BindingInput bindingInput = oper.getBindingInput();
|
|
if (bindingInput != null) {
|
|
Iterator it = bindingInput.getExtensibilityElements().iterator();
|
|
while (it.hasNext()) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) it.next();
|
|
if (ee instanceof IMSMessage) {
|
|
IMSInput imsInput = new IMSInput();
|
|
IMSMessage imsMessage = (IMSMessage) ee;
|
|
imsInput.setImsMessage(imsMessage);
|
|
endpoint.setIMSOperationInput(imsOperation, imsInput);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BindingOutput bindingOutput = oper.getBindingOutput();
|
|
if (bindingOutput != null) {
|
|
Iterator it2 = bindingOutput.getExtensibilityElements().iterator();
|
|
while (it2.hasNext()) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) it2.next();
|
|
if (ee instanceof IMSMessage) {
|
|
IMSOutput imsOutput = new IMSOutput();
|
|
IMSMessage imsMessage = (IMSMessage) ee;
|
|
imsOutput.setImsMessage(imsMessage);
|
|
endpoint.setIMSOperationOutput(imsOperation, imsOutput);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
protected Map getIMSOperationMepTypes(Definition def, String serviceName, String endpointName, int direction) {
|
|
Map mepTypes = new HashMap();
|
|
Binding binding = getBinding(def, serviceName, endpointName);
|
|
if (binding != null) {
|
|
List bindingOperations = binding.getBindingOperations();
|
|
Iterator operIter = bindingOperations == null ? null : bindingOperations.iterator();
|
|
while (operIter != null && operIter.hasNext()) {
|
|
BindingOperation oper = (BindingOperation) operIter.next();
|
|
List extElems = oper.getExtensibilityElements();
|
|
|
|
Iterator extIter = extElems == null ? null : extElems.iterator();
|
|
while (extIter != null && extIter.hasNext()) {
|
|
ExtensibilityElement ee = (ExtensibilityElement) extIter.next();
|
|
if (IMSOperation.class.isInstance(ee)) {
|
|
String mep = EndpointMessageType.UNSUPPORTED;
|
|
if (oper.getOperation().getStyle() != null) {
|
|
mep = determineMEP(direction, oper);
|
|
} else {
|
|
// for some reason, sometimes the operation type is not set
|
|
// so the BC will populate it based on the WSDL definition
|
|
// for now, we only handle Request-response and one-way.
|
|
// anything else is not supported and should be caught in WSDL
|
|
// validation
|
|
Operation operation = oper.getOperation();
|
|
OperationType type = null;
|
|
if (operation.getInput() != null && operation.getOutput() != null) {
|
|
type = OperationType.REQUEST_RESPONSE;
|
|
} else if (operation.getInput() != null) {
|
|
type = OperationType.ONE_WAY;
|
|
}
|
|
if (type != null) {
|
|
mep = determineMEP(direction, type);
|
|
}
|
|
}
|
|
mepTypes.put(QName.valueOf(oper.getName()), mep);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return mepTypes;
|
|
}
|
|
|
|
public Map getPartEncoderMapping(Endpoint currEndpoint) throws Exception {
|
|
|
|
Definition def = currEndpoint.getDefinition();
|
|
String serviceName = currEndpoint.getServiceName().toString();
|
|
String endpointName = currEndpoint.getEndpointName();
|
|
int direction = currEndpoint.getEndpointType();
|
|
Map imsOperations = currEndpoint.getIMSOperations();
|
|
Map mepTypes = currEndpoint.getOperationMsgExchangePatterns();
|
|
Map partMapping = new HashMap();
|
|
|
|
// Don't support inline encoder schemas
|
|
if (mXsds.size() <= 0) {
|
|
return partMapping;
|
|
}
|
|
|
|
Service service = def.getService(QName.valueOf(serviceName));
|
|
Port port = service.getPort(endpointName);
|
|
PortType portType = port.getBinding().getPortType();
|
|
|
|
/**
|
|
* Locate the operation we are interested in. There may be multiple operations by the same
|
|
* name (operation overloading) and the WSDL spec does not allow it. The uniqueness should
|
|
* be guaranteed by the examination of input and/or output names. The WSDL validation
|
|
* should've been enforced the uniqueness at design time. For the time being, we will assume
|
|
* that we don't have operation overloading.
|
|
*/
|
|
javax.wsdl.Message wsdlMessage = null;
|
|
Map parts = new HashMap();
|
|
for (Iterator opnameIter = imsOperations.keySet().iterator(); opnameIter.hasNext();) {
|
|
String mep = null;
|
|
String encodingStyle = null;
|
|
|
|
QName operationName = (QName) opnameIter.next();
|
|
IMSOperation imsOperation = (IMSOperation) imsOperations.get(operationName);
|
|
mep = (String) mepTypes.get(operationName);
|
|
|
|
for (Iterator operIter = portType.getOperations().iterator(); operIter.hasNext();) {
|
|
Operation op = (Operation) operIter.next();
|
|
if (op.getName().equals(operationName.toString()) || op.getName().equals(operationName.getLocalPart())) {
|
|
/**
|
|
* There is nothing in the WSDL spec that says that the part name has to be
|
|
* unique within the WSDL document, so we need to prefix the part name with the
|
|
* message name.
|
|
*/
|
|
|
|
Input input = op.getInput();
|
|
if (input != null) {
|
|
IMSInput imsInput = imsOperation.getIMSOperationInput();
|
|
if (imsInput == null) {
|
|
throw new Exception(mMessages.getString("IMSBC-E00904.No_Ims_Input",
|
|
operationName.toString()));
|
|
}
|
|
wsdlMessage = input.getMessage();
|
|
parts = wsdlMessage.getParts();
|
|
for (Iterator partIter = parts.values().iterator(); partIter.hasNext();) {
|
|
Part aPart = (Part) partIter.next();
|
|
String partName = aPart.getName();
|
|
QName type = (aPart.getElementName() != null) ? aPart.getElementName()
|
|
: aPart.getTypeName();
|
|
|
|
// locate the XSD file based on the part type namespace
|
|
String namespace = type.getNamespaceURI();
|
|
String xsdFileLoc = getXsdFileLocation(namespace);
|
|
if (xsdFileLoc != null) {
|
|
// Determine on which extensibility element the encoding style is
|
|
// defined
|
|
if (direction == EndpointType.INBOUND) { // Consumer
|
|
IMSMessage imsMessage = imsInput.getImsMessage();
|
|
if (imsMessage == null) {
|
|
throw new Exception(mMessages.getString("IMSBC-E00905.No_Ims_Message",
|
|
operationName.toString()));
|
|
}
|
|
if (imsMessage.getUseType().equals(IMSMessage.USE_TYPE_ENCODED)) {
|
|
encodingStyle = imsMessage.getEncodingStyle();
|
|
} else {
|
|
continue;
|
|
}
|
|
if (encodingStyle == null || encodingStyle.equals("")) {
|
|
throw new Exception(mMessages.getString(
|
|
"IMSBC-E00906.No_Encoding_Style",
|
|
operationName.toString()));
|
|
}
|
|
} else { // Provider
|
|
IMSMessage imsMessage = imsInput.getImsMessage();
|
|
if (imsMessage == null) {
|
|
throw new Exception(mMessages.getString("IMSBC-E00907.No_Ims_Ouput",
|
|
operationName.toString()));
|
|
}
|
|
if (imsMessage.getUseType().equals(IMSMessage.USE_TYPE_ENCODED)) {
|
|
encodingStyle = imsMessage.getEncodingStyle();
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
if (encodingStyle == null || encodingStyle.equals("")) {
|
|
throw new Exception(mMessages.getString(
|
|
"IMSBC-E00906.No_Encoding_Style",
|
|
operationName.toString()));
|
|
}
|
|
}
|
|
|
|
Encoder encoder = null;
|
|
MetaRef metaRef = new MyMetaRef(xsdFileLoc, type);
|
|
if (mEncoderMap.get(metaRef) != null) {
|
|
encoder = (Encoder) mEncoderMap.get(metaRef);
|
|
} else {
|
|
EncoderFactory encoderFactory = EncoderFactory.newInstance();
|
|
encoder = encoderFactory.newEncoder(encoderFactory.makeType(encodingStyle), metaRef);
|
|
mEncoderMap.put(metaRef, encoder);
|
|
}
|
|
partMapping.put(wsdlMessage.getQName() + partName, encoder);
|
|
}
|
|
}
|
|
}
|
|
|
|
Output output = op.getOutput();
|
|
if (output != null) {
|
|
IMSOutput imsOutput = imsOperation.getIMSOperationOutput();
|
|
if (imsOutput == null) {
|
|
throw new Exception(mMessages.getString("IMSBC-E00907.No_Ims_Ouput",
|
|
operationName.toString()));
|
|
}
|
|
|
|
wsdlMessage = output.getMessage();
|
|
parts = wsdlMessage.getParts();
|
|
for (Iterator partIter = parts.values().iterator(); partIter.hasNext();) {
|
|
Part aPart = (Part) partIter.next();
|
|
String partName = aPart.getName();
|
|
QName type = (aPart.getElementName() != null) ? aPart.getElementName()
|
|
: aPart.getTypeName();
|
|
|
|
// locate the XSD file based on the part type namespace
|
|
String namespace = type.getNamespaceURI();
|
|
String xsdFileLoc = getXsdFileLocation(namespace);
|
|
if (xsdFileLoc != null) {
|
|
if (direction == EndpointType.INBOUND && mep.equals(EndpointMessageType.IN_OUT)) {
|
|
// Consumer request-response operations
|
|
IMSMessage imsMessage = imsOutput.getImsMessage();
|
|
if (imsMessage == null) {
|
|
throw new Exception(mMessages.getString("IMSBC-E00905.No_Ims_Message",
|
|
operationName.toString()));
|
|
}
|
|
|
|
if (imsMessage.getUseType().equals(IMSMessage.USE_TYPE_ENCODED)) {
|
|
encodingStyle = imsMessage.getEncodingStyle();
|
|
} else {
|
|
continue;
|
|
}
|
|
if (encodingStyle == null || encodingStyle.equals("")) {
|
|
throw new Exception(mMessages.getString(
|
|
"IMSBC-E00906.No_Encoding_Style",
|
|
operationName.toString()));
|
|
}
|
|
|
|
Encoder encoder = null;
|
|
MetaRef metaRef = new MyMetaRef(xsdFileLoc, type);
|
|
if (mEncoderMap.get(metaRef) != null) {
|
|
encoder = (Encoder) mEncoderMap.get(metaRef);
|
|
} else {
|
|
EncoderFactory encoderFactory = EncoderFactory.newInstance();
|
|
encoder = encoderFactory.newEncoder(encoderFactory.makeType(encodingStyle),
|
|
metaRef);
|
|
mEncoderMap.put(metaRef, encoder);
|
|
}
|
|
partMapping.put(wsdlMessage.getQName() + partName, encoder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return partMapping;
|
|
}
|
|
|
|
public void clearEncoderCache() {
|
|
mEncoderMap.clear();
|
|
}
|
|
|
|
/**
|
|
* Determine the message exchange pattern. For handling 1.1 wsdls, map transmission primitives
|
|
* to the closest message exchange pattern, taking into account the endpoint direction direction
|
|
* inbound: request-response and solicit-response -> in-out one-way and notification -> in-only
|
|
* direction outbound: request-response and solicit-response -> out-in one-way and notification ->
|
|
* out-only
|
|
*
|
|
* @param pm the endpoint configuration from the portmap
|
|
* @param po the binding operation definition from the wsdl
|
|
* @return the message exchange pattern, null if no mapping could be determined.
|
|
*/
|
|
protected String determineMEP(int direction, BindingOperation bo) {
|
|
String mep = null;
|
|
OperationType type = bo.getOperation().getStyle();
|
|
|
|
if (direction == EndpointType.INBOUND) {
|
|
if (type.equals(OperationType.REQUEST_RESPONSE)) {
|
|
mep = EndpointMessageType.IN_OUT;
|
|
} else if (type.equals(OperationType.ONE_WAY)) {
|
|
mep = EndpointMessageType.IN_ONLY;
|
|
} else {
|
|
mep = EndpointMessageType.UNSUPPORTED;
|
|
}
|
|
} else {
|
|
if (type == null) {
|
|
return null;
|
|
// Not sure why type is not populated for some outbound binding operations.
|
|
}
|
|
if (type.equals(OperationType.REQUEST_RESPONSE) || type.equals(OperationType.SOLICIT_RESPONSE)) {
|
|
mep = EndpointMessageType.OUT_IN;
|
|
} else if (type.equals(OperationType.ONE_WAY) || type.equals(OperationType.NOTIFICATION)) {
|
|
mep = EndpointMessageType.OUT_ONLY;
|
|
}
|
|
}
|
|
return mep;
|
|
}
|
|
|
|
protected String determineMEP(int direction, OperationType type) {
|
|
String mep = null;
|
|
|
|
if (direction == EndpointType.INBOUND) {
|
|
if (type.equals(OperationType.REQUEST_RESPONSE)) {
|
|
mep = EndpointMessageType.IN_OUT;
|
|
} else if (type.equals(OperationType.ONE_WAY)) {
|
|
mep = EndpointMessageType.IN_ONLY;
|
|
} else {
|
|
mep = EndpointMessageType.UNSUPPORTED;
|
|
}
|
|
} else {
|
|
if (type.equals(OperationType.REQUEST_RESPONSE) || type.equals(OperationType.SOLICIT_RESPONSE)) {
|
|
mep = EndpointMessageType.OUT_IN;
|
|
} else if (type.equals(OperationType.ONE_WAY) || type.equals(OperationType.NOTIFICATION)) {
|
|
mep = EndpointMessageType.OUT_ONLY;
|
|
}
|
|
}
|
|
return mep;
|
|
}
|
|
|
|
protected String getXsdFileLocation(String aNamespace) {
|
|
String xsdFileLoc = null;
|
|
File aXsdFile = null;
|
|
|
|
try {
|
|
for (int ii = 0; ii < mXsds.size(); ii++) {
|
|
aXsdFile = (File) mXsds.get(ii);
|
|
FastSchemaFactory factory = FastSchemaFactory.getInstance();
|
|
FastSchema schema = factory.newFastSchema(aXsdFile.getAbsolutePath());
|
|
if (aNamespace.equals(schema.getTargetNamespace())) {
|
|
xsdFileLoc = aXsdFile.getAbsolutePath();
|
|
break;
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
mLogger.log(Level.SEVERE, mMessages.getString("IMSBC-E00908.Wcf_Cannot_Parse_Xsd", aXsdFile.getName()));
|
|
}
|
|
|
|
return xsdFileLoc;
|
|
}
|
|
|
|
/**
|
|
* An implementation of the MetaRef interface
|
|
*/
|
|
private class MyMetaRef implements MetaRef {
|
|
private final String mXsdPath;
|
|
|
|
private final QName mRootElemName;
|
|
|
|
private final String mToString;
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
protected MyMetaRef(String xsdLoc) {
|
|
this(xsdLoc, null);
|
|
}
|
|
|
|
/**
|
|
* Alternative constructor that constructs a MetaRef object
|
|
* with the file path location of the main XSD and
|
|
* qualified name of the root element
|
|
*/
|
|
protected MyMetaRef(String xsdLoc, QName rootElemName) {
|
|
mXsdPath = xsdLoc;
|
|
mRootElemName = rootElemName;
|
|
mToString = toString();
|
|
}
|
|
|
|
/**
|
|
* Return the file path location of the main XSD
|
|
* @return the path of the main meta file
|
|
*/
|
|
public String getPath() {
|
|
return mXsdPath;
|
|
}
|
|
|
|
/**
|
|
* Return the QName of the root element.
|
|
* @return the QName of the root element
|
|
*/
|
|
public QName getRootElemName() {
|
|
return mRootElemName;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public URL getURL(){
|
|
return null;
|
|
}
|
|
|
|
public String toString() {
|
|
return mXsdPath + mRootElemName.toString();
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof MyMetaRef)) {
|
|
return false;
|
|
}
|
|
return mToString.equals(((MyMetaRef) obj).mToString);
|
|
}
|
|
|
|
public int hashCode() {
|
|
return mToString.hashCode();
|
|
}
|
|
}
|
|
|
|
}
|