3:24 p.m.
Author: rsearls
Date: 2014-05-29 16:24:44 -0400 (Thu, 29 May 2014)
New Revision: 18704
Added:
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/WSDLSoapAddressRewriteInterceptor.java
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/util/
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/util/WSDLSoapAddressRewriteUtils.java
Log:
returning new classes
Added:
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/WSDLSoapAddressRewriteInterceptor.java
===================================================================
---
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/WSDLSoapAddressRewriteInterceptor.java
(rev 0)
+++
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/WSDLSoapAddressRewriteInterceptor.java 2014-05-29
20:24:44 UTC (rev 18704)
@@ -0,0 +1,120 @@
+package org.jboss.wsf.stack.cxf.interceptor;
+
+import org.apache.cxf.binding.soap.interceptor.EndpointSelectionInterceptor;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.UrlUtils;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.frontend.WSDLGetInterceptor;
+import org.apache.cxf.frontend.WSDLGetOutInterceptor;
+import org.apache.cxf.interceptor.*;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageImpl;
+import org.apache.cxf.phase.AbstractPhaseInterceptor;
+import org.apache.cxf.phase.Phase;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.transport.common.gzip.GZIPOutInterceptor;
+import org.jboss.wsf.stack.cxf.interceptor.util.WSDLSoapAddressRewriteUtils;
+import org.w3c.dom.Document;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * This is a customization of org.apache.cxf.frontend.WSDLGetInterceptor. It
+ * enables the handling of rewriting the path of a URL.
+ * Date: 5/19/14
+ */
+public class WSDLSoapAddressRewriteInterceptor extends
AbstractPhaseInterceptor<Message> {
+ public static final WSDLSoapAddressRewriteInterceptor INSTANCE =
+ new WSDLSoapAddressRewriteInterceptor();
+ private static final String TRANSFORM_SKIP = "transform.skip";
+ private Interceptor<Message> wsdlGetOutInterceptor =
WSDLGetOutInterceptor.INSTANCE;
+
+ public WSDLSoapAddressRewriteInterceptor() {
+ super(Phase.READ);
+ getAfter().add(EndpointSelectionInterceptor.class.getName());
+ }
+
+ public WSDLSoapAddressRewriteInterceptor(Interceptor<Message> outInterceptor) {
+ this();
+ // Let people override the wsdlGetOutInterceptor
+ wsdlGetOutInterceptor = outInterceptor;
+ }
+
+ public void handleMessage(Message message) throws Fault {
+ String method = (String)message.get(Message.HTTP_REQUEST_METHOD);
+ String query = (String)message.get(Message.QUERY_STRING);
+
+ if (!"GET".equals(method) || StringUtils.isEmpty(query)) {
+ return;
+ }
+
+ String baseUri = (String)message.get(Message.REQUEST_URL);
+ String ctx = (String)message.get(Message.PATH_INFO);
+
+ Map<String, String> map = UrlUtils.parseQueryString(query);
+ if (isRecognizedQuery(map, baseUri, ctx,
message.getExchange().getEndpoint().getEndpointInfo())) {
+ Document doc = getDocument(message, baseUri, map, ctx);
+
+ Endpoint e = message.getExchange().get(Endpoint.class);
+ Message mout = new MessageImpl();
+ mout.setExchange(message.getExchange());
+ mout = e.getBinding().createMessage(mout);
+
mout.setInterceptorChain(OutgoingChainInterceptor.getOutInterceptorChain(message.getExchange()));
+ message.getExchange().setOutMessage(mout);
+
+ mout.put(WSDLGetInterceptor.DOCUMENT_HOLDER, doc);
+ mout.put(Message.CONTENT_TYPE, "text/xml");
+
+ // just remove the interceptor which should not be used
+ cleanUpOutInterceptors(mout);
+
+ // notice this is being added after the purge above, don't swap the order!
+ mout.getInterceptorChain().add(wsdlGetOutInterceptor);
+
+ message.getExchange().put(TRANSFORM_SKIP, Boolean.TRUE);
+ // skip the service executor and goto the end of the chain.
+ message.getInterceptorChain().doInterceptStartingAt(
+ message,
+ OutgoingChainInterceptor.class.getName());
+ }
+ }
+
+ protected void cleanUpOutInterceptors(Message outMessage) {
+ // TODO - how can I improve this to provide a specific interceptor chain that just
has the
+ // stax, gzip and message sender components, while also ensuring that GZIP is only
provided
+ // if its already configured for the endpoint.
+ Iterator<Interceptor<? extends Message>> iterator =
outMessage.getInterceptorChain().iterator();
+ while (iterator.hasNext()) {
+ Interceptor<? extends Message> inInterceptor = iterator.next();
+ if (!inInterceptor.getClass().equals(StaxOutInterceptor.class)
+ && !inInterceptor.getClass().equals(GZIPOutInterceptor.class)
+ && !inInterceptor.getClass().equals(MessageSenderInterceptor.class))
{
+ outMessage.getInterceptorChain().remove(inInterceptor);
+ }
+ }
+
+ }
+
+ private Document getDocument(Message message, String base, Map<String, String>
params, String ctxUri) {
+ // cannot have two wsdl's being generated for the same endpoint at the same
+ // time as the addresses may get mixed up
+ // For WSDL's the WSDLWriter does not share any state between documents.
+ // For XSD's, the WSDLSoapAddressRewriteUtils makes a copy of any XSD schema
documents before updating
+ // any addresses and returning them, so for both WSDL and XSD this is the only part
that needs
+ // to be synchronized.
+ synchronized (message.getExchange().getEndpoint()) {
+ return new WSDLSoapAddressRewriteUtils().getDocument(message, base, params,
ctxUri,
+ message.getExchange().getEndpoint().getEndpointInfo());
+ }
+ }
+
+ private boolean isRecognizedQuery(Map<String, String> map, String baseUri,
String ctx,
+ EndpointInfo endpointInfo) {
+ if (map.containsKey("wsdl") || map.containsKey("xsd")) {
+ return true;
+ }
+ return false;
+ }
+
+}
Added:
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/util/WSDLSoapAddressRewriteUtils.java
===================================================================
---
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/util/WSDLSoapAddressRewriteUtils.java
(rev 0)
+++
stack/cxf/branches/rsearls/modules/server/src/main/java/org/jboss/wsf/stack/cxf/interceptor/util/WSDLSoapAddressRewriteUtils.java 2014-05-29
20:24:44 UTC (rev 18704)
@@ -0,0 +1,245 @@
+package org.jboss.wsf.stack.cxf.interceptor.util;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.catalog.OASISCatalogManager;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.frontend.WSDLGetUtils;
+import org.apache.cxf.frontend.WSDLQueryException;
+import org.apache.cxf.helpers.CastUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+import org.apache.cxf.service.model.EndpointInfo;
+import org.apache.cxf.service.model.SchemaInfo;
+import org.apache.cxf.staxutils.StaxUtils;
+import org.apache.cxf.wsdl.WSDLManager;
+import org.apache.cxf.wsdl11.ResourceManagerWSDLLocator;
+import org.apache.cxf.wsdl11.ServiceWSDLBuilder;
+import org.jboss.ws.common.management.AbstractServerConfig;
+import org.jboss.wsf.spi.management.ServerConfig;
+import org.jboss.wsf.stack.cxf.addressRewrite.SEDProcessor;
+import org.jboss.wsf.stack.cxf.addressRewrite.SoapAddressRewriteHelper;
+import org.jboss.wsf.stack.cxf.interceptor.WSDLSoapAddressRewriteInterceptor;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+
+import javax.wsdl.Definition;
+import javax.wsdl.extensions.schema.SchemaReference;
+import javax.wsdl.xml.WSDLWriter;
+import javax.xml.transform.dom.DOMSource;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.security.AccessController;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+import org.apache.cxf.common.util.StringUtils;
+
+
+/**
+ * User: rsearls
+ * Date: 5/19/14
+ */
+public class WSDLSoapAddressRewriteUtils extends WSDLGetUtils {
+
+ private static final String WSDLS_KEY = WSDLSoapAddressRewriteUtils.class.getName() +
".WSDLs";
+ private static final String SCHEMAS_KEY = WSDLSoapAddressRewriteUtils.class.getName()
+ ".Schemas";
+
+ private static final Logger LOG =
LogUtils.getL7dLogger(WSDLSoapAddressRewriteInterceptor.class);
+
+ public WSDLSoapAddressRewriteUtils() {
+
+ }
+
+ @Override
+ public Document getDocument(Message message,
+ String base,
+ Map<String, String> params,
+ String ctxUri,
+ EndpointInfo endpointInfo) {
+ try {
+ Bus bus = message.getExchange().getBus();
+ Object prop = message.getContextualProperty(PUBLISHED_ENDPOINT_URL);
+ if (prop == null) {
+ prop = endpointInfo.getProperty(PUBLISHED_ENDPOINT_URL);
+ }
+ if (prop != null) {
+ base = String.valueOf(prop);
+ }
+ String wsdl = params.get("wsdl");
+ if (wsdl != null) {
+ // Always use the URL decoded version to ensure that we have a
+ // canonical representation of the import URL for lookup.
+ wsdl = URLDecoder.decode(wsdl, "utf-8");
+ }
+
+ String xsd = params.get("xsd");
+ if (xsd != null) {
+ // Always use the URL decoded version to ensure that we have a
+ // canonical representation of the import URL for lookup.
+ xsd = URLDecoder.decode(xsd, "utf-8");
+ }
+
+ Map<String, Definition> mp = CastUtils.cast((Map<?,
?>)endpointInfo.getService()
+ .getProperty(WSDLS_KEY));
+ Map<String, SchemaReference> smp = CastUtils.cast((Map<?,
?>)endpointInfo.getService()
+ .getProperty(SCHEMAS_KEY));
+
+ if (mp == null) {
+ endpointInfo.getService().setProperty(WSDLS_KEY,
+ new ConcurrentHashMap<String, Definition>(8, 0.75f, 4));
+ mp = CastUtils.cast((Map<?, ?>)endpointInfo.getService()
+ .getProperty(WSDLS_KEY));
+ }
+ if (smp == null) {
+ endpointInfo.getService().setProperty(SCHEMAS_KEY,
+ new ConcurrentHashMap<String, SchemaReference>(8, 0.75f, 4));
+ smp = CastUtils.cast((Map<?, ?>)endpointInfo.getService()
+ .getProperty(SCHEMAS_KEY));
+ }
+
+ if (!mp.containsKey("")) {
+ ServiceWSDLBuilder builder =
+ new ServiceWSDLBuilder(bus, endpointInfo.getService());
+
+ builder.setUseSchemaImports(
+ MessageUtils.getContextualBoolean(message, WSDL_CREATE_IMPORTS, false));
+
+ // base file name is ignored if createSchemaImports == false!
+ builder.setBaseFileName(endpointInfo.getService().getName().getLocalPart());
+
+ Definition def = builder.build(new HashMap<String, SchemaInfo>());
+
+ mp.put("", def);
+ updateDefinition(bus, def, mp, smp, base, endpointInfo, "");
+ }
+
+
+ Document doc;
+ if (xsd == null) {
+ Definition def = mp.get(wsdl);
+ if (def == null) {
+ String wsdl2 =
resolveWithCatalogs(OASISCatalogManager.getCatalogManager(bus),
+ wsdl,
+ base);
+ if (wsdl2 != null) {
+ def = mp.get(wsdl2);
+ }
+ }
+ if (def == null) {
+ throw new WSDLQueryException(new
org.apache.cxf.common.i18n.Message("WSDL_NOT_FOUND",
+ LOG, wsdl), null);
+ }
+
+ synchronized (def) {
+ //writing a def is not threadsafe. Sync on it to make sure
+ //we don't get any ConcurrentModificationExceptions
+ if (endpointInfo.getProperty(PUBLISHED_ENDPOINT_URL) != null) {
+ String epurl =
+ String.valueOf(endpointInfo.getProperty(PUBLISHED_ENDPOINT_URL));
+ updatePublishedEndpointUrl(epurl, def, endpointInfo.getName());
+ base = epurl;
+ } else {
+ // When using replacement path, must set replacement path in the active
url.
+ ServerConfig sc = getServerConfig();
+ if (SoapAddressRewriteHelper.isSoapAddressRewrite(getServerConfig())
+ &&
endpointInfo.getAddress().contains(ServerConfig.UNDEFINED_HOSTNAME)) {
+ String epurl = SoapAddressRewriteHelper.rewriteSoapAddress(sc,
base);
+ updatePublishedEndpointUrl(epurl, def, endpointInfo.getName());
+ base = epurl;
+ }
+ }
+
+ WSDLWriter wsdlWriter = bus.getExtension(WSDLManager.class)
+ .getWSDLFactory().newWSDLWriter();
+
def.setExtensionRegistry(bus.getExtension(WSDLManager.class).getExtensionRegistry());
+ doc = wsdlWriter.getDocument(def);
+ }
+ } else {
+ SchemaReference si = smp.get(xsd);
+ if (si == null) {
+ String xsd2 =
resolveWithCatalogs(OASISCatalogManager.getCatalogManager(bus),
+ xsd,
+ base);
+ if (xsd2 != null) {
+ si = smp.get(xsd2);
+ }
+ }
+ if (si == null) {
+ throw new WSDLQueryException(new
org.apache.cxf.common.i18n.Message("SCHEMA_NOT_FOUND",
+ LOG, wsdl), null);
+ }
+
+ String uri = si.getReferencedSchema().getDocumentBaseURI();
+ uri = resolveWithCatalogs(OASISCatalogManager.getCatalogManager(bus),
+ uri,
+ si.getReferencedSchema().getDocumentBaseURI());
+ if (uri == null) {
+ uri = si.getReferencedSchema().getDocumentBaseURI();
+ }
+ ResourceManagerWSDLLocator rml = new ResourceManagerWSDLLocator(uri,
+ bus);
+
+ InputSource src = rml.getBaseInputSource();
+ if (src.getByteStream() != null || src.getCharacterStream() != null) {
+ doc = StaxUtils.read(src);
+ } else { // last resort lets try for the referenced schema itself.
+ // its not thread safe if we use the same document
+ doc = StaxUtils.read(
+ new
DOMSource(si.getReferencedSchema().getElement().getOwnerDocument()));
+ }
+ }
+
+ updateDoc(doc, base, mp, smp, message, xsd, wsdl);
+
+ return doc;
+ } catch (WSDLQueryException wex) {
+ throw wex;
+ } catch (Exception wex) {
+ throw new WSDLQueryException(new
org.apache.cxf.common.i18n.Message("COULD_NOT_PROVIDE_WSDL",
+ LOG,
+ base), wex);
+ }
+ }
+
+ @Override
+ public void updateWSDLPublishedEndpointAddress(Definition def, EndpointInfo
endpointInfo)
+ {
+ synchronized (def) {
+ //writing a def is not threadsafe. Sync on it to make sure
+ //we don't get any ConcurrentModificationExceptions
+ if (endpointInfo.getProperty(PUBLISHED_ENDPOINT_URL) != null) {
+ String epurl =
+ String.valueOf(endpointInfo.getProperty(PUBLISHED_ENDPOINT_URL));
+ updatePublishedEndpointUrl(epurl, def, endpointInfo.getName());
+ }
+ /** rls test else {
+ // When using replacement path must set replacement path in active url.
+ ServerConfig sc = getServerConfig();
+ if (sc.isModifySOAPAddress() &&
!StringUtils.isEmpty(sc.getWebServicePath()
+ &&
endpointInfo.getAddress().contains(ServerConfig.UNDEFINED_HOSTNAME)) {
+ try {
+ String base = endpointInfo.getAddress();
+ URL baseUrl = new URL(base);
+ //String tmpPath =
Unix4j.builder().echo(baseUrl.getPath()).sed(sc.getWebServicePath()).toStringResult();
+ String tmpPath =
SEDProcessor.newInstance(sc.getWebServicePath()).processLine(baseUrl.getPath());
+ String epurl = base.replace(baseUrl.getPath(), tmpPath);
+ updatePublishedEndpointUrl(epurl, def, endpointInfo.getName());
+ //base = epurl;
+ } catch (Exception e){
+ // TODO fix
+ LOG.info(e.toString());
+ }
+ }
+ }
+ **/
+ }
+ }
+
+ private static ServerConfig getServerConfig() {
+ if(System.getSecurityManager() == null) {
+ return AbstractServerConfig.getServerIntegrationServerConfig();
+ }
+ return
AccessController.doPrivileged(AbstractServerConfig.GET_SERVER_INTEGRATION_SERVER_CONFIG);
+ }
+}