com.sun.xml.rpc.processor.modeler.nometadata.NoMetadataModeler Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxrpc-impl Show documentation
Show all versions of jaxrpc-impl Show documentation
JAXRPC Reference Implementation
/*
* Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package com.sun.xml.rpc.processor.modeler.nometadata;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import javax.xml.namespace.QName;
import org.xml.sax.InputSource;
import com.sun.xml.rpc.processor.ProcessorOptions;
import com.sun.xml.rpc.processor.config.NamespaceMappingInfo;
import com.sun.xml.rpc.processor.config.NamespaceMappingRegistryInfo;
import com.sun.xml.rpc.processor.config.NoMetadataModelInfo;
import com.sun.xml.rpc.processor.model.Block;
import com.sun.xml.rpc.processor.model.Fault;
import com.sun.xml.rpc.processor.model.Model;
import com.sun.xml.rpc.processor.model.ModelException;
import com.sun.xml.rpc.processor.model.ModelObject;
import com.sun.xml.rpc.processor.model.ModelProperties;
import com.sun.xml.rpc.processor.model.Operation;
import com.sun.xml.rpc.processor.model.Parameter;
import com.sun.xml.rpc.processor.model.Port;
import com.sun.xml.rpc.processor.model.Request;
import com.sun.xml.rpc.processor.model.Response;
import com.sun.xml.rpc.processor.model.Service;
import com.sun.xml.rpc.processor.model.java.JavaArrayType;
import com.sun.xml.rpc.processor.model.java.JavaException;
import com.sun.xml.rpc.processor.model.java.JavaInterface;
import com.sun.xml.rpc.processor.model.java.JavaMethod;
import com.sun.xml.rpc.processor.model.java.JavaParameter;
import com.sun.xml.rpc.processor.model.java.JavaStructureMember;
import com.sun.xml.rpc.processor.model.java.JavaStructureType;
import com.sun.xml.rpc.processor.model.java.JavaType;
import com.sun.xml.rpc.processor.model.soap.RPCRequestUnorderedStructureType;
import com.sun.xml.rpc.processor.model.soap.RPCResponseStructureType;
import com.sun.xml.rpc.processor.model.soap.SOAPOrderedStructureType;
import com.sun.xml.rpc.processor.model.soap.SOAPStructureMember;
import com.sun.xml.rpc.processor.model.soap.SOAPStructureType;
import com.sun.xml.rpc.processor.model.soap.SOAPType;
import com.sun.xml.rpc.processor.modeler.JavaSimpleTypeCreator;
import com.sun.xml.rpc.processor.modeler.Modeler;
import com.sun.xml.rpc.processor.modeler.ModelerException;
import com.sun.xml.rpc.processor.modeler.rmi.RmiUtils;
import com.sun.xml.rpc.processor.modeler.wsdl.SchemaAnalyzer;
import com.sun.xml.rpc.processor.util.ClassNameCollector;
import com.sun.xml.rpc.processor.util.ProcessorEnvironment;
import com.sun.xml.rpc.processor.util.StringUtils;
import com.sun.xml.rpc.util.localization.LocalizableMessageFactory;
import com.sun.xml.rpc.util.xml.XmlUtil;
import com.sun.xml.rpc.wsdl.document.Binding;
import com.sun.xml.rpc.wsdl.document.BindingOperation;
import com.sun.xml.rpc.wsdl.document.BindingFault;
import com.sun.xml.rpc.wsdl.document.Documentation;
import com.sun.xml.rpc.wsdl.document.MessagePart;
import com.sun.xml.rpc.wsdl.document.OperationStyle;
import com.sun.xml.rpc.wsdl.document.PortType;
import com.sun.xml.rpc.wsdl.document.WSDLConstants;
import com.sun.xml.rpc.wsdl.document.WSDLDocument;
import com.sun.xml.rpc.wsdl.document.schema.SchemaConstants;
import com.sun.xml.rpc.wsdl.document.schema.SchemaKinds;
import com.sun.xml.rpc.wsdl.document.soap.SOAPAddress;
import com.sun.xml.rpc.wsdl.document.soap.SOAPBinding;
import com.sun.xml.rpc.wsdl.document.soap.SOAPBody;
import com.sun.xml.rpc.wsdl.document.soap.SOAPConstants;
import com.sun.xml.rpc.wsdl.document.soap.SOAPFault;
import com.sun.xml.rpc.wsdl.document.soap.SOAPHeader;
import com.sun.xml.rpc.wsdl.document.soap.SOAPOperation;
import com.sun.xml.rpc.wsdl.document.soap.SOAPStyle;
import com.sun.xml.rpc.wsdl.framework.Entity;
import com.sun.xml.rpc.wsdl.framework.Extensible;
import com.sun.xml.rpc.wsdl.framework.Extension;
import com.sun.xml.rpc.wsdl.framework.GloballyKnown;
import com.sun.xml.rpc.wsdl.framework.NoSuchEntityException;
import com.sun.xml.rpc.wsdl.framework.ParseException;
import com.sun.xml.rpc.wsdl.framework.ParserListener;
import com.sun.xml.rpc.wsdl.framework.ValidationException;
import com.sun.xml.rpc.wsdl.parser.WSDLParser;
import com.sun.xml.rpc.wsdl.parser.SOAPEntityReferenceValidator;
/**
*
* @author JAX-RPC Development Team
*/
public class NoMetadataModeler implements Modeler {
public NoMetadataModeler(NoMetadataModelInfo modelInfo,
Properties options) {
this.modelInfo = modelInfo;
env = (ProcessorEnvironment)
modelInfo.getConfiguration().getEnvironment();
this.options = options;
namespaceMappingRegistry = modelInfo.getNamespaceMappingRegistry();
messageFactory =
new LocalizableMessageFactory("com.sun.xml.rpc.resources.modeler");
}
public ProcessorEnvironment getProcessorEnvironment() {
return env;
}
public NamespaceMappingRegistryInfo getNamespaceMappingRegistryInfo() {
return namespaceMappingRegistry;
}
public Model getModel() {
return model;
}
public Model buildModel() {
try {
WSDLParser parser = new WSDLParser();
InputSource inputSource = new InputSource(modelInfo.getLocation());
parser.addParserListener(new ParserListener() {
public void ignoringExtension(QName name, QName parent) {
if (parent.equals(WSDLConstants.QNAME_TYPES)) {
// check for schema element with wrong namespace URI
if (name.getLocalPart().equals("schema") &&
!name.getNamespaceURI().equals("")) {
warn("wsdlmodeler.warning.ignoringUnrecognizedSchemaExtension",
name.getNamespaceURI());
}
}
}
public void doneParsingEntity(QName element, Entity entity) {}
});
// Added useWSIBasicProfile parameter to WSDLParser.parse() that it
// can generate warnings when f:wsi is set to true
// This is done to validate WSDL for wsi compliant
boolean useWSIBasicProfile = Boolean.valueOf(options.getProperty(
ProcessorOptions.USE_WSI_BASIC_PROFILE)).booleanValue();
WSDLDocument document = parser.parse(inputSource,
useWSIBasicProfile);
document.validateLocally();
boolean validateWSDL =
Boolean.valueOf(options.getProperty(
ProcessorOptions.VALIDATE_WSDL_PROPERTY)).booleanValue();
if (validateWSDL) {
document.validate(new SOAPEntityReferenceValidator());
}
Model model = internalBuildModel(document);
ClassNameCollector collector = new ClassNameCollector();
collector.process(model);
if (collector.getConflictingClassNames().isEmpty()) {
return model;
} else {
// give up
StringBuffer conflictList = new StringBuffer();
boolean first = true;
for (Iterator iter =
collector.getConflictingClassNames().iterator();
iter.hasNext();) {
if (!first) {
conflictList.append(", ");
} else {
first = false;
}
conflictList.append((String) iter.next());
}
throw new ModelerException(
"wsdlmodeler.unsolvableNamingConflicts",
conflictList.toString());
}
} catch (ModelException e) {
throw new ModelerException(e);
} catch (ParseException e) {
throw new ModelerException(e);
} catch (ValidationException e) {
throw new ModelerException(e);
} finally {
analyzer = null;
}
}
private Model internalBuildModel(WSDLDocument document) {
QName modelName = new QName(
document.getDefinitions().getTargetNamespaceURI(),
document.getDefinitions().getName() == null ? "model" :
document.getDefinitions().getName());
Model model = new Model(modelName);
model.setProperty(ModelProperties.PROPERTY_MODELER_NAME,
this.getClass().getName());
javaTypes = new JavaSimpleTypeCreator();
javaExceptions = new HashMap();
analyzer = new SchemaAnalyzer(document, modelInfo, options,
new HashSet(), javaTypes);
// grab target namespace
model.setTargetNamespaceURI(
document.getDefinitions().getTargetNamespaceURI());
setDocumentationIfPresent(model,
document.getDefinitions().getDocumentation());
boolean hasServices = document.getDefinitions().services().hasNext();
if (hasServices) {
boolean gotOne = false;
for (Iterator iter =
document.getDefinitions().services(); iter.hasNext();) {
com.sun.xml.rpc.wsdl.document.Service service =
(com.sun.xml.rpc.wsdl.document.Service) iter.next();
if (gotOne) {
throw new ModelerException(
"nometadatamodeler.error.moreThanOneServiceDefinition");
}
processService(service, model, document);
gotOne = true;
}
} else {
// emit an error if there are no service definitions
throw new ModelerException(
"nometadatamodeler.error.noServiceDefinitionsFound");
}
return model;
}
protected void processService(
com.sun.xml.rpc.wsdl.document.Service wsdlService,
Model model, WSDLDocument document) {
QName serviceQName = getQNameOf(wsdlService);
if (modelInfo.getServiceName() != null &&
!modelInfo.getServiceName().equals(serviceQName)) {
throw new ModelerException(
"nometadatamodeler.error.incorrectServiceName",
serviceQName.toString());
}
String serviceInterface = null;
if (modelInfo.getServiceInterfaceName() != null) {
serviceInterface = modelInfo.getServiceInterfaceName();
} else {
serviceInterface = "";
String javaPackageName = getJavaPackageName(serviceQName);
if (javaPackageName == null &&
modelInfo.getJavaPackageName() != null &&
!modelInfo.getJavaPackageName().equals("")) {
javaPackageName = modelInfo.getJavaPackageName();
}
if (javaPackageName == null) {
throw new ModelerException(
"nometadatamodeler.error.cannotMapNamespace",
serviceQName.getNamespaceURI());
}
serviceInterface = javaPackageName + ".";
serviceInterface += env.getNames().validJavaClassName(wsdlService.getName());
}
Service service = new Service(serviceQName,
new JavaInterface(serviceInterface, serviceInterface+"Impl"));
setDocumentationIfPresent(service, wsdlService.getDocumentation());
boolean gotOne = false;
for (Iterator iter = wsdlService.ports(); iter.hasNext();) {
if (gotOne) {
throw new ModelerException(
"nometadatamodeler.error.moreThanOnePortDefinition",
wsdlService.getName());
}
com.sun.xml.rpc.wsdl.document.Port port =
(com.sun.xml.rpc.wsdl.document.Port) iter.next();
boolean processed = processPort(port, service, document);
if (!processed) {
throw new ModelerException(
"nometadatamodeler.error.failedToProcessPort",
port.getName());
}
gotOne = true;
}
if (!gotOne) {
throw new ModelerException(
"nometadatamodeler.error.noPortsInService",
wsdlService.getName());
}
model.addService(service);
verifyServiceInterface(service);
}
protected boolean processPort(com.sun.xml.rpc.wsdl.document.Port wsdlPort,
Service service, WSDLDocument document) {
try {
QName portQName = getQNameOf(wsdlPort);
if (modelInfo.getPortName() != null &&
!modelInfo.getPortName().equals(portQName)) {
throw new ModelerException("nometadatamodeler.error.incorrectPortName", portQName.toString());
}
Port port = new Port(portQName);
setDocumentationIfPresent(port, wsdlPort.getDocumentation());
SOAPAddress soapAddress =
(SOAPAddress) getExtensionOfType(wsdlPort, SOAPAddress.class);
if (soapAddress == null) {
warn("wsdlmodeler.warning.ignoringNonSOAPPort.noAddress",
wsdlPort.getName());
return false;
}
port.setAddress(soapAddress.getLocation());
Binding binding = wsdlPort.resolveBinding(document);
PortType portType = binding.resolvePortType(document);
// find out the SOAP binding extension, if any
SOAPBinding soapBinding =
(SOAPBinding) getExtensionOfType(binding, SOAPBinding.class);
if (soapBinding == null) {
warn("wsdlmodeler.warning.ignoringNonSOAPPort",
wsdlPort.getName());
return false;
}
if (soapBinding.getTransport() == null ||
!soapBinding.getTransport().equals(
SOAPConstants.URI_SOAP_TRANSPORT_HTTP)) {
warn("wsdlmodeler.warning.ignoringSOAPBinding.nonHTTPTransport",
wsdlPort.getName());
return false;
}
boolean hasOverloadedOperations = false;
Set operationNames = new HashSet();
for (Iterator iter = portType.operations(); iter.hasNext();) {
com.sun.xml.rpc.wsdl.document.Operation operation =
(com.sun.xml.rpc.wsdl.document.Operation) iter.next();
if (operationNames.contains(operation.getName())) {
hasOverloadedOperations = true;
break;
}
operationNames.add(operation.getName());
}
if (hasOverloadedOperations) {
throw new ModelerException(
"nometadatamodeler.error.overloadedOperationsFound",
wsdlPort.getName());
}
port.setProperty(ModelProperties.PROPERTY_WSDL_PORT_NAME,
getQNameOf(wsdlPort));
port.setProperty(ModelProperties.PROPERTY_WSDL_PORT_TYPE_NAME,
getQNameOf(portType));
port.setProperty(ModelProperties.PROPERTY_WSDL_BINDING_NAME,
getQNameOf(binding));
boolean hasOperations = false;
for (Iterator iter = binding.operations(); iter.hasNext();) {
BindingOperation bindingOperation =
(BindingOperation) iter.next();
com.sun.xml.rpc.wsdl.document.Operation portTypeOperation =
null;
Set operations =
portType.getOperationsNamed(bindingOperation.getName());
if (operations.size() == 0) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.notInPortType",
new Object[] { bindingOperation.getName(),
binding.getName() });
} else if (operations.size() == 1) {
portTypeOperation =
(com.sun.xml.rpc.wsdl.document.Operation)
operations.iterator().next();
} else {
boolean found = false;
String expectedInputName =
bindingOperation.getInput().getName();
String expectedOutputName =
bindingOperation.getOutput().getName();
for (Iterator iter2 = operations.iterator();
iter2.hasNext();) {
com.sun.xml.rpc.wsdl.document.Operation
candidateOperation =
(com.sun.xml.rpc.wsdl.document.Operation)
iter2.next();
if (expectedInputName == null) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.missingInputName",
new Object[] { bindingOperation.getName(),
binding.getName() });
}
if (expectedOutputName == null) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.missingOutputName",
new Object[] { bindingOperation.getName(),
binding.getName() });
}
if (expectedInputName.equals(
candidateOperation.getInput().getName()) &&
expectedOutputName.equals(
candidateOperation.getOutput().getName())) {
if (found) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.multipleMatchingOperations",
new Object[] { bindingOperation.getName(),
binding.getName() });
} else {
// got it!
found = true;
portTypeOperation = candidateOperation;
}
}
}
if (!found) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.notFound",
new Object[] { bindingOperation.getName(),
binding.getName() });
}
}
Operation operation = processSOAPOperation(
new ProcessSOAPOperationInfo(
port,
wsdlPort,
portTypeOperation,
bindingOperation,
soapBinding,
document));
if (operation != null) {
port.addOperation(operation);
hasOperations = true;
}
}
if (!hasOperations) {
// emit a warning if there are no operations
warn("wsdlmodeler.warning.noOperationsInPort",
wsdlPort.getName());
}
// now deal with the configured handlers
port.setClientHandlerChainInfo(
modelInfo.getClientHandlerChainInfo());
port.setServerHandlerChainInfo(
modelInfo.getServerHandlerChainInfo());
service.addPort(port);
createJavaInterfaceForPort(port);
verifyJavaInterface(port);
// generate stub and tie class names
String stubClassName = env.getNames().stubFor(port, null);
String tieClassName = env.getNames().tieFor(port, null);
port.setProperty(ModelProperties.PROPERTY_STUB_CLASS_NAME,
stubClassName);
port.setProperty(ModelProperties.PROPERTY_TIE_CLASS_NAME,
tieClassName);
return true;
} catch (NoSuchEntityException e) {
// should not happen
return false;
}
}
protected Operation processSOAPOperation(ProcessSOAPOperationInfo info) {
Operation operation = new Operation(new QName(
null, info.bindingOperation.getName()));
setDocumentationIfPresent(operation,
info.portTypeOperation.getDocumentation());
//fix for bug 4851104
if (info.portTypeOperation.getStyle() !=
OperationStyle.REQUEST_RESPONSE &&
info.portTypeOperation.getStyle() != OperationStyle.ONE_WAY) {
// we only support request-response right now
warn("wsdlmodeler.warning.ignoringOperation.notRequestResponse",
info.portTypeOperation.getName());
return null;
}
SOAPStyle soapStyle = info.soapBinding.getStyle();
// find out the SOAP operation extension, if any
SOAPOperation soapOperation = (SOAPOperation)
getExtensionOfType(info.bindingOperation, SOAPOperation.class);
if (soapOperation != null) {
if (soapOperation.getStyle() != null) {
soapStyle = soapOperation.getStyle();
}
if (soapOperation.getSOAPAction() != null) {
operation.setSOAPAction(soapOperation.getSOAPAction());
}
}
operation.setStyle(soapStyle);
String uniqueOperationName = info.portTypeOperation.getName();
info.operation = operation;
info.uniqueOperationName = uniqueOperationName;
if (soapStyle == SOAPStyle.RPC) {
// rpc style
return processSOAPOperationRPCStyle(info);
} else {
// document style
throw new ModelerException(
"nometadatamodeler.error.documentStyleOperation",
operation.getName().getLocalPart());
}
}
protected Operation processSOAPOperationRPCStyle(
ProcessSOAPOperationInfo info) {
//fix for bug 4851104
boolean isRequestResponse =
info.portTypeOperation.getStyle() ==
OperationStyle.REQUEST_RESPONSE;
Request request = new Request();
Response response = new Response();
SOAPBody soapRequestBody = (SOAPBody) getExtensionOfType(
info.bindingOperation.getInput(), SOAPBody.class);
if (soapRequestBody == null) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.inputMissingSoapBody",
new Object[] { info.bindingOperation.getName() });
}
SOAPBody soapResponseBody = null;
//fix for bug 4851104
if (isRequestResponse) {
soapResponseBody = (SOAPBody) getExtensionOfType(
info.bindingOperation.getOutput(), SOAPBody.class);
if (soapResponseBody == null) {
// the WSDL document is invalid
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.outputMissingSoapBody",
new Object[] { info.bindingOperation.getName() });
}
}
if ((soapRequestBody.isLiteral() || !tokenListContains(
soapRequestBody.getEncodingStyle(),
SOAPConstants.NS_SOAP_ENCODING)) ||
(soapResponseBody != null && (soapResponseBody.isLiteral() ||
!tokenListContains(soapResponseBody.getEncodingStyle(),
SOAPConstants.NS_SOAP_ENCODING)))) {
throw new ModelerException(
"nometadatamodeler.error.operationNotEncoded",
info.portTypeOperation.getName());
}
String requestNamespaceURI = soapRequestBody.getNamespace();
if (requestNamespaceURI == null) {
/* the WSDL document is invalid
* at least, that's my interpretation of section 3.5 of the
* WSDL 1.1 spec!
*/
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.inputSoapBody.missingNamespace",
new Object[] { info.bindingOperation.getName() });
}
String responseNamespaceURI = null;
//fix for bug 4851104
if (isRequestResponse) {
responseNamespaceURI = soapResponseBody.getNamespace();
if (responseNamespaceURI == null) {
/* the WSDL document is invalid
* at least, that's my interpretation of section 3.5 of the
* WSDL 1.1 spec!
*/
throw new ModelerException(
"wsdlmodeler.invalid.bindingOperation.outputSoapBody.missingNamespace",
new Object[] { info.bindingOperation.getName() });
}
}
String structureNamePrefix = null;
QName portTypeName = (QName) info.modelPort.getProperty(
ModelProperties.PROPERTY_WSDL_PORT_TYPE_NAME);
if (portTypeName != null) {
structureNamePrefix = getNonQualifiedNameFor(portTypeName);
} else {
structureNamePrefix = getNonQualifiedNameFor(info.modelPort.getName());
}
structureNamePrefix += "_";
QName requestBodyName =
new QName(requestNamespaceURI, info.portTypeOperation.getName());
SOAPStructureType requestBodyType =
new RPCRequestUnorderedStructureType(requestBodyName);
JavaStructureType requestBodyJavaType =
new JavaStructureType(makePackageQualified(
StringUtils.capitalize(structureNamePrefix +
info.uniqueOperationName) + "_RequestStruct",
requestBodyName),
false, requestBodyType);
requestBodyType.setJavaType(requestBodyJavaType);
Block requestBodyBlock = new Block(requestBodyName, requestBodyType);
request.addBodyBlock(requestBodyBlock);
//fix for bug 4851104
SOAPStructureType responseBodyType = null;
JavaStructureType responseBodyJavaType = null;
Block responseBodyBlock = null;
if (isRequestResponse) {
QName responseBodyName = new QName(responseNamespaceURI,
info.portTypeOperation.getName() + "Response");
responseBodyType = new RPCResponseStructureType(responseBodyName);
responseBodyJavaType = new JavaStructureType(makePackageQualified(
StringUtils.capitalize(structureNamePrefix +
info.uniqueOperationName + "_ResponseStruct"),
responseBodyName),
false, responseBodyType);
responseBodyType.setJavaType(responseBodyJavaType);
responseBodyBlock = new Block(responseBodyName, responseBodyType);
response.addBodyBlock(responseBodyBlock);
}
if (soapRequestBody.getParts() != null) {
// right now, we only support body parts
// TODO - fix this to include the case of © 2015 - 2025 Weber Informatics LLC | Privacy Policy