jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/server/EndpointFactory.java

-:8c0b6bccfe47
+:0989ad8c0860
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 package com.sun.xml.internal.ws.server;
 import com.sun.istack.internal.NotNull;
 import com.sun.istack.internal.Nullable;
+import com.sun.xml.internal.stream.buffer.MutableXMLStreamBuffer;
 import com.sun.xml.internal.ws.api.BindingID;
 import com.sun.xml.internal.ws.api.WSBinding;
-import com.sun.xml.internal.ws.api.policy.PolicyResolverFactory;
+import com.sun.xml.internal.ws.api.WSFeatureList;
-import com.sun.xml.internal.ws.api.policy.PolicyResolver;
+import com.sun.xml.internal.ws.api.databinding.DatabindingConfig;
+import com.sun.xml.internal.ws.api.databinding.DatabindingFactory;
+import com.sun.xml.internal.ws.api.databinding.MetadataReader;
 import com.sun.xml.internal.ws.api.databinding.WSDLGenInfo;
-import com.sun.xml.internal.ws.api.databinding.DatabindingFactory;
-import com.sun.xml.internal.ws.api.databinding.DatabindingConfig;
 import com.sun.xml.internal.ws.api.model.SEIModel;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;
-import com.sun.xml.internal.ws.api.pipe.Tube;
+import com.sun.xml.internal.ws.api.policy.PolicyResolver;
-import com.sun.xml.internal.ws.api.server.*;
+import com.sun.xml.internal.ws.api.policy.PolicyResolverFactory;
+import com.sun.xml.internal.ws.api.server.AsyncProvider;
+import com.sun.xml.internal.ws.api.server.Container;
+import com.sun.xml.internal.ws.api.server.ContainerResolver;
+import com.sun.xml.internal.ws.api.server.InstanceResolver;
+import com.sun.xml.internal.ws.api.server.Invoker;
+import com.sun.xml.internal.ws.api.server.SDDocument;
+import com.sun.xml.internal.ws.api.server.SDDocumentSource;
+import com.sun.xml.internal.ws.api.server.WSEndpoint;
+import com.sun.xml.internal.ws.api.streaming.XMLStreamReaderFactory;
 import com.sun.xml.internal.ws.api.wsdl.parser.WSDLParserExtension;
 import com.sun.xml.internal.ws.api.wsdl.parser.XMLEntityResolver;
 import com.sun.xml.internal.ws.api.wsdl.parser.XMLEntityResolver.Parser;
 import com.sun.xml.internal.ws.api.wsdl.writer.WSDLGeneratorExtension;
 import com.sun.xml.internal.ws.binding.BindingImpl;
 import com.sun.xml.internal.ws.binding.SOAPBindingImpl;
 import com.sun.xml.internal.ws.binding.WebServiceFeatureList;
 import com.sun.xml.internal.ws.model.AbstractSEIModelImpl;
+import com.sun.xml.internal.ws.model.ReflectAnnotationReader;
 import com.sun.xml.internal.ws.model.RuntimeModeler;
 import com.sun.xml.internal.ws.model.SOAPSEIModel;
 import com.sun.xml.internal.ws.model.wsdl.WSDLModelImpl;
 import com.sun.xml.internal.ws.model.wsdl.WSDLPortImpl;
 import com.sun.xml.internal.ws.model.wsdl.WSDLServiceImpl;
+import com.sun.xml.internal.ws.policy.PolicyMap;
+import com.sun.xml.internal.ws.policy.jaxws.PolicyUtil;
 import com.sun.xml.internal.ws.resources.ServerMessages;
 import com.sun.xml.internal.ws.server.provider.ProviderInvokerTube;
 import com.sun.xml.internal.ws.server.sei.SEIInvokerTube;
 import com.sun.xml.internal.ws.util.HandlerAnnotationInfo;
 import com.sun.xml.internal.ws.util.HandlerAnnotationProcessor;
 import com.sun.xml.internal.ws.util.ServiceConfigurationError;
 import com.sun.xml.internal.ws.util.ServiceFinder;
+import com.sun.xml.internal.ws.util.xml.XmlUtil;
 import com.sun.xml.internal.ws.wsdl.parser.RuntimeWSDLParser;
-import com.sun.xml.internal.ws.wsdl.writer.WSDLGenerator;
-import com.sun.xml.internal.ws.policy.PolicyMap;
-import com.sun.xml.internal.ws.policy.jaxws.PolicyUtil;
 import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import javax.jws.WebService;
 import javax.xml.namespace.QName;
 import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
 import javax.xml.ws.Provider;
 import javax.xml.ws.WebServiceException;
+import javax.xml.ws.WebServiceFeature;
 import javax.xml.ws.WebServiceProvider;
-import javax.xml.ws.WebServiceFeature;
 import javax.xml.ws.soap.SOAPBinding;
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 EntityResolver resolver, boolean isTransportSynchronous, boolean isStandard) {
 if(implType ==null)
 throw new IllegalArgumentException();
+MetadataReader metadataReader = getExternalMetadatReader(implType, binding);
 if (isStandard) {
-verifyImplementorClass(implType);
+verifyImplementorClass(implType, metadataReader);
 }
 if (invoker == null) {
 invoker = InstanceResolver.createDefault(implType).createInvoker();
 }
 if(container==null)
 container = ContainerResolver.getInstance().getContainer();
 if(serviceName==null)
-serviceName = getDefaultServiceName(implType);
+serviceName = getDefaultServiceName(implType, metadataReader);
 if(portName==null)
-portName = getDefaultPortName(serviceName,implType);
+portName = getDefaultPortName(serviceName,implType, metadataReader);
 {// error check
 String serviceNS = serviceName.getNamespaceURI();
 String portNS = portName.getNamespaceURI();
 if (!serviceNS.equals(portNS)) {
 verifyPrimaryWSDL(primaryWsdl, serviceName);
 }
 QName portTypeName = null;
 if (isStandard && implType.getAnnotation(WebServiceProvider.class)==null) {
-portTypeName = RuntimeModeler.getPortTypeName(implType);
+portTypeName = RuntimeModeler.getPortTypeName(implType, metadataReader);
 }
 // Categorises the documents as WSDL, Schema etc
 List<SDDocumentImpl> docList = categoriseMetadata(md, serviceName, portTypeName);
 // Finds the primary WSDL and makes sure that metadata doesn't have
 // two concrete or abstract WSDLs
-SDDocumentImpl primaryDoc = findPrimary(docList);
+SDDocumentImpl primaryDoc = primaryWsdl != null ? SDDocumentImpl.create(primaryWsdl,serviceName,portTypeName) : findPrimary(docList);
 EndpointAwareTube terminal;
 WSDLPortImpl wsdlPort = null;
 AbstractSEIModelImpl seiModel = null;
 // create WSDL model
 if (primaryDoc != null) {
-wsdlPort = getWSDLPort(primaryDoc, docList, serviceName, portName, container);
+wsdlPort = getWSDLPort(primaryDoc, docList, serviceName, portName, container, resolver);
 }
 WebServiceFeatureList features=((BindingImpl)binding).getFeatures();
 if (isStandard) {
 features.parseAnnotations(implType);
 policyMap = PolicyResolverFactory.create().resolve(
 new PolicyResolver.ServerContext(null, container, implType, false));
 configFtrs = PolicyUtil.getPortScopedFeatures(policyMap,serviceName,portName);
 }
 features.mergeFeatures(configFtrs, true);
-terminal = createProviderInvokerTube(implType,binding,invoker);
+terminal = createProviderInvokerTube(implType, binding, invoker, container);
 } else {
 // Create runtime model for non Provider endpoints
 seiModel = createSEIModel(wsdlPort, implType, serviceName, portName, binding);
 if(binding instanceof SOAPBindingImpl){
 //set portKnownHeaders on Binding, so that they can be used for MU processing
 }
 // Generate WSDL for SEI endpoints(not for Provider endpoints)
 if (primaryDoc == null) {
 primaryDoc = generateWSDL(binding, seiModel, docList, container, implType);
 // create WSDL model
-wsdlPort = getWSDLPort(primaryDoc, docList, serviceName, portName, container);
+wsdlPort = getWSDLPort(primaryDoc, docList, serviceName, portName, container, resolver);
 seiModel.freeze(wsdlPort);
 }
 policyMap = wsdlPort.getOwner().getParent().getPolicyMap();
 // New Features might have been added in WSDL through Policy.
 //Merge features from WSDL and other policy configuration
 if (processHandlerAnnotation) {
 processHandlerAnnotation(binding, implType, serviceName, portName);
 }
 // Selects only required metadata for this endpoint from the passed-in metadata
 if (primaryDoc != null) {
-docList = findMetadataClosure(primaryDoc, docList);
+docList = findMetadataClosure(primaryDoc, docList, resolver);
 }
 ServiceDefinitionImpl serviceDefiniton = (primaryDoc != null) ? new ServiceDefinitionImpl(docList, primaryDoc) : null;
 return create(serviceName, portName, binding, container, seiModel, wsdlPort, implType, serviceDefiniton,
 terminal, isTransportSynchronous, policyMap);
 }
 protected EndpointAwareTube createSEIInvokerTube(AbstractSEIModelImpl seiModel, Invoker invoker, WSBinding binding) {
 return new SEIInvokerTube(seiModel,invoker,binding);
 }
-protected <T> EndpointAwareTube createProviderInvokerTube(Class<T> implType, WSBinding binding, Invoker invoker) {
+protected <T> EndpointAwareTube createProviderInvokerTube(final Class<T> implType, final WSBinding binding,
-return ProviderInvokerTube.create(implType, binding, invoker);
+final Invoker invoker, final Container container) {
-}
+return ProviderInvokerTube.create(implType, binding, invoker, container);
+}
 /**
 * Goes through the original metadata documents and collects the required ones.
 * This done traversing from primary WSDL and its imports until it builds a
 * complete set of documents(transitive closure) for the endpoint.
 *
 * @param primaryDoc primary WSDL doc
 * @param docList complete metadata
 * @return new metadata that doesn't contain extraneous documnets.
 */
-private static List<SDDocumentImpl> findMetadataClosure(SDDocumentImpl primaryDoc, List<SDDocumentImpl> docList) {
+private static List<SDDocumentImpl> findMetadataClosure(SDDocumentImpl primaryDoc, List<SDDocumentImpl> docList, EntityResolver resolver) {
 // create a map for old metadata
 Map<String, SDDocumentImpl> oldMap = new HashMap<String, SDDocumentImpl>();
 for(SDDocumentImpl doc : docList) {
 oldMap.put(doc.getSystemId().toString(), doc);
 }
 while(!remaining.isEmpty()) {
 String url = remaining.remove(0);
 SDDocumentImpl doc = oldMap.get(url);
 if (doc == null) {
 // old metadata doesn't have this imported doc, may be external
-continue;
+if (resolver != null) {
+try {
+InputSource source = resolver.resolveEntity(null, url);
+if (source != null) {
+MutableXMLStreamBuffer xsb = new MutableXMLStreamBuffer();
+XMLStreamReader reader = XmlUtil.newXMLInputFactory(true).createXMLStreamReader(source.getByteStream());
+xsb.createFromXMLStreamReader(reader);
+SDDocumentSource sdocSource = SDDocumentImpl.create(new URL(url), xsb);
+doc = SDDocumentImpl.create(sdocSource, null, null);
+}
+} catch (Exception ex) {
+ex.printStackTrace();
+}
+}
 }
 // Check if new metadata already contains this doc
-if (!newMap.containsKey(url)) {
+if (doc != null && !newMap.containsKey(url)) {
 newMap.put(url, doc);
 remaining.addAll(doc.getImports());
 }
 }
 List<SDDocumentImpl> newMetadata = new ArrayList<SDDocumentImpl>();
 * @throws java.lang.IllegalArgumentException
 *      If it doesn't have any one of @WebService or @WebServiceProvider
 *      If it has both @WebService and @WebServiceProvider annotations
 */
 public static boolean verifyImplementorClass(Class<?> clz) {
-WebServiceProvider wsProvider = clz.getAnnotation(WebServiceProvider.class);
+return verifyImplementorClass(clz, null);
-WebService ws = clz.getAnnotation(WebService.class);
+}
+/**
+* Verifies if the endpoint implementor class has @WebService or @WebServiceProvider
+* annotation; passing MetadataReader instance allows to read annotations from
+* xml descriptor instead of class's annotations
+*
+* @return
+*       true if it is a Provider or AsyncProvider endpoint
+*       false otherwise
+* @throws java.lang.IllegalArgumentException
+*      If it doesn't have any one of @WebService or @WebServiceProvider
+*      If it has both @WebService and @WebServiceProvider annotations
+*/
+public static boolean verifyImplementorClass(Class<?> clz, MetadataReader metadataReader) {
+if (metadataReader == null) {
+metadataReader = new ReflectAnnotationReader();
+}
+WebServiceProvider wsProvider = metadataReader.getAnnotation(WebServiceProvider.class, clz);
+WebService ws = metadataReader.getAnnotation(WebService.class, clz);
 if (wsProvider == null && ws == null) {
 throw new IllegalArgumentException(clz +" has neither @WebService nor @WebServiceProvider annotation");
 }
 if (wsProvider != null && ws != null) {
 throw new IllegalArgumentException(clz +" has both @WebService and @WebServiceProvider annotations");
 config.setWSBinding(binding);
 //              config.setFeatures(binding.getFeatures().toArray());
 //              config.getMappingInfo().setBindingID(binding.getBindingId());
 config.setClassLoader(implType.getClassLoader());
 config.getMappingInfo().setPortName(portName);
+config.setMetadataReader(getExternalMetadatReader(implType, binding));
 com.sun.xml.internal.ws.db.DatabindingImpl rt = (com.sun.xml.internal.ws.db.DatabindingImpl)fac.createRuntime(config);
 return (AbstractSEIModelImpl) rt.getModel();
+}
+public static MetadataReader getExternalMetadatReader(Class<?> implType, WSBinding binding) {
+com.oracle.webservices.internal.api.databinding.ExternalMetadataFeature ef = binding.getFeature(
+com.oracle.webservices.internal.api.databinding.ExternalMetadataFeature.class);
+// TODO-Miran: would it be necessary to disable secure xml processing?
+if (ef != null)
+return ef.getMetadataReader(implType.getClassLoader(), false);
+return null;
 }
 /**
 *Set the mtom enable setting from wsdl model (mtom policy assertion) on to @link WSBinding} if DD has
 * not already set it on BindingID. Also check conflicts.
 * annotations {@link WebServiceProvider}, {@link WebService} on implementorClass to get PortName.
 *
 * @return non-null service name
 */
 public static @NotNull QName getDefaultServiceName(Class<?> implType) {
-return getDefaultServiceName(implType, true);
+return getDefaultServiceName(implType, null);
+}
+public static @NotNull QName getDefaultServiceName(Class<?> implType, MetadataReader metadataReader) {
+return getDefaultServiceName(implType, true, metadataReader);
 }
 public static @NotNull QName getDefaultServiceName(Class<?> implType, boolean isStandard) {
+return getDefaultServiceName(implType, isStandard, null);
+}
+public static @NotNull QName getDefaultServiceName(Class<?> implType, boolean isStandard, MetadataReader metadataReader) {
+if (metadataReader == null) {
+metadataReader = new ReflectAnnotationReader();
+}
 QName serviceName;
-WebServiceProvider wsProvider = implType.getAnnotation(WebServiceProvider.class);
+WebServiceProvider wsProvider = metadataReader.getAnnotation(WebServiceProvider.class, implType);
 if (wsProvider!=null) {
 String tns = wsProvider.targetNamespace();
 String local = wsProvider.serviceName();
 serviceName = new QName(tns, local);
 } else {
-serviceName = RuntimeModeler.getServiceName(implType, isStandard);
+serviceName = RuntimeModeler.getServiceName(implType, metadataReader, isStandard);
 }
 assert serviceName != null;
 return serviceName;
 }
 * annotations on implementorClass to get PortName.
 *
 * @return non-null port name
 */
 public static @NotNull QName getDefaultPortName(QName serviceName, Class<?> implType) {
-return getDefaultPortName(serviceName, implType, true);
+return getDefaultPortName(serviceName, implType, null);
+}
+public static @NotNull QName getDefaultPortName(QName serviceName, Class<?> implType, MetadataReader metadataReader) {
+return getDefaultPortName(serviceName, implType, true, metadataReader);
 }
 public static @NotNull QName getDefaultPortName(QName serviceName, Class<?> implType, boolean isStandard) {
+return getDefaultPortName(serviceName, implType, isStandard, null);
+}
+public static @NotNull QName getDefaultPortName(QName serviceName, Class<?> implType, boolean isStandard, MetadataReader metadataReader) {
+if (metadataReader == null) {
+metadataReader = new ReflectAnnotationReader();
+}
 QName portName;
-WebServiceProvider wsProvider = implType.getAnnotation(WebServiceProvider.class);
+WebServiceProvider wsProvider = metadataReader.getAnnotation(WebServiceProvider.class, implType);
 if (wsProvider!=null) {
 String tns = wsProvider.targetNamespace();
 String local = wsProvider.portName();
 portName = new QName(tns, local);
 } else {
-portName = RuntimeModeler.getPortName(implType, serviceName.getNamespaceURI(), isStandard);
+portName = RuntimeModeler.getPortName(implType, metadataReader, serviceName.getNamespaceURI(), isStandard);
 }
 assert portName != null;
 return portName;
 }
 *      endpoint implementation class
 *      make sure that you called {@link #verifyImplementorClass} on it.
 * @return wsdl if there is wsdlLocation, else null
 */
 public static @Nullable String getWsdlLocation(Class<?> implType) {
-String wsdl;
+return getWsdlLocation(implType, new ReflectAnnotationReader());
-WebService ws = implType.getAnnotation(WebService.class);
+}
+/**
+* Returns the wsdl from @WebService, or @WebServiceProvider annotation using
+* wsdlLocation element.
+*
+* @param implType
+*      endpoint implementation class
+*      make sure that you called {@link #verifyImplementorClass} on it.
+* @return wsdl if there is wsdlLocation, else null
+*/
+public static @Nullable String getWsdlLocation(Class<?> implType, MetadataReader metadataReader) {
+if (metadataReader == null) {
+metadataReader = new ReflectAnnotationReader();
+}
+WebService ws = metadataReader.getAnnotation(WebService.class, implType);
 if (ws != null) {
-wsdl = ws.wsdlLocation();
+return nullIfEmpty(ws.wsdlLocation());
 } else {
 WebServiceProvider wsProvider = implType.getAnnotation(WebServiceProvider.class);
 assert wsProvider != null;
-wsdl = wsProvider.wsdlLocation();
+return nullIfEmpty(wsProvider.wsdlLocation());
 }
-if (wsdl.length() < 1) {
+}
-wsdl = null;
-}
+private static String nullIfEmpty(String string) {
-return wsdl;
+if (string.length() < 1) {
+string = null;
+}
+return string;
 }
 /**
 * Generates the WSDL and XML Schema for the endpoint if necessary
 * It generates WSDL only for SOAP1.1, and for XSOAP1.2 bindings
 WSDLGenInfo wsdlGenInfo = new WSDLGenInfo();
 wsdlGenInfo.setWsdlResolver(wsdlResolver);
 wsdlGenInfo.setContainer(container);
 wsdlGenInfo.setExtensions(ServiceFinder.find(WSDLGeneratorExtension.class).toArray());
 wsdlGenInfo.setInlineSchemas(false);
+wsdlGenInfo.setSecureXmlProcessingDisabled(isSecureXmlProcessingDisabled(binding.getFeatures()));
 seiModel.getDatabinding().generateWSDL(wsdlGenInfo);
 //        WSDLGenerator wsdlGen = new WSDLGenerator(seiModel, wsdlResolver, binding, container, implType, false,
 //                ServiceFinder.find(WSDLGeneratorExtension.class).toArray());
 //        wsdlGen.doGeneration();
 return wsdlResolver.updateDocs();
+}
+private static boolean isSecureXmlProcessingDisabled(WSFeatureList featureList) {
+// TODO-Miran: would it be necessary to disable secure xml processing?
+return false;
 }
 /**
 * Builds {@link SDDocumentImpl} from {@link SDDocumentSource}.
 */
 * @param portName port name in WSDL
 * @param container container in which this service is running
 * @return non-null wsdl port object
 */
 private static @NotNull WSDLPortImpl getWSDLPort(SDDocumentSource primaryWsdl, List<? extends SDDocumentSource> metadata,
-@NotNull QName serviceName, @NotNull QName portName, Container container) {
+@NotNull QName serviceName, @NotNull QName portName, Container container,
+EntityResolver resolver) {
 URL wsdlUrl = primaryWsdl.getSystemId();
 try {
 // TODO: delegate to another entity resolver
 WSDLModelImpl wsdlDoc = RuntimeWSDLParser.parse(
-new Parser(primaryWsdl), new EntityResolverImpl(metadata),
+new Parser(primaryWsdl), new EntityResolverImpl(metadata, resolver),
 false, container, ServiceFinder.find(WSDLParserExtension.class).toArray());
 if(wsdlDoc.getServices().size() == 0) {
 throw new ServerRtException(ServerMessages.localizableRUNTIME_PARSER_WSDL_NOSERVICE_IN_WSDLMODEL(wsdlUrl));
 }
 WSDLServiceImpl wsdlService = wsdlDoc.getService(serviceName);
 /**
 * {@link XMLEntityResolver} that can resolve to {@link SDDocumentSource}s.
 */
 private static final class EntityResolverImpl implements XMLEntityResolver {
 private Map<String,SDDocumentSource> metadata = new HashMap<String,SDDocumentSource>();
+private EntityResolver resolver;
-public EntityResolverImpl(List<? extends SDDocumentSource> metadata) {
+public EntityResolverImpl(List<? extends SDDocumentSource> metadata, EntityResolver resolver) {
 for (SDDocumentSource doc : metadata) {
 this.metadata.put(doc.getSystemId().toExternalForm(),doc);
 }
+this.resolver = resolver;
 }
 public Parser resolveEntity (String publicId, String systemId) throws IOException, XMLStreamException {
 if (systemId != null) {
 SDDocumentSource doc = metadata.get(systemId);
 if (doc != null)
 return new Parser(doc);
 }
+if (resolver != null) {
+try {
+InputSource source = resolver.resolveEntity(publicId, systemId);
+if (source != null) {
+Parser p = new Parser(null, XMLStreamReaderFactory.create(source, true));
+return p;
+}
+} catch (SAXException e) {
+throw new XMLStreamException(e);
+}
+}
 return null;
 }
 }

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/ws/server/EndpointFactory.java

src/share/jaxws_classes/com/sun/xml/internal/ws/server/EndpointFactory.java