Author: jim.ma Date: 2012-08-09 11:41:46 -0400 (Thu, 09 Aug 2012) New Revision: 16586 Added: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandler.java thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandlerTest.java thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/FaultToEndpointServer.java thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/WSAFaultToClientServerTest.java Removed: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandler.java thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandlerTest.java Modified: thirdparty/cxf/branches/cxf-2.4.8/rt/bindings/soap/src/main/java/org/apache/cxf/binding/soap/interceptor/Soap11FaultOutInterceptor.java thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/ContextUtils.java thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/MAPCodec.java Log: [JBPAPP-9342][JBPAPP-9464]:Back port the fix of one-way/request-response faultTo is not correctly transmitted Modified: thirdparty/cxf/branches/cxf-2.4.8/rt/bindings/soap/src/main/java/org/apache/cxf/binding/soap/interceptor/Soap11FaultOutInterceptor.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/bindings/soap/src/main/java/org/apache/cxf/binding/soap/interceptor/Soap11FaultOutInterceptor.java 2012-08-09 07:52:21 UTC (rev 16585) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/bindings/soap/src/main/java/org/apache/cxf/binding/soap/interceptor/Soap11FaultOutInterceptor.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -85,7 +85,12 @@ writer.writeStartElement("faultstring"); if (fault.getMessage() != null) { - writer.writeCharacters(fault.getMessage()); + if (message.get("forced.faultstring") != null) { + writer.writeCharacters((String)message.get("forced.faultstring")); + } else { + writer.writeCharacters(fault.getMessage()); + } + } else { writer.writeCharacters("Fault occurred while processing."); } Modified: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/ContextUtils.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/ContextUtils.java 2012-08-09 07:52:21 UTC (rev 16585) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/ContextUtils.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -53,6 +53,7 @@ import org.apache.cxf.message.Message; import org.apache.cxf.message.MessageImpl; import org.apache.cxf.message.MessageUtils; +import org.apache.cxf.phase.PhaseInterceptorChain; import org.apache.cxf.service.model.BindingFaultInfo; import org.apache.cxf.service.model.BindingOperationInfo; import org.apache.cxf.service.model.EndpointInfo; @@ -372,22 +373,22 @@ * @param inMAPs the inbound MAPs * @param inMessage the current message */ + //CHECKSTYLE:OFF Max executable statement count limitation public static void rebaseResponse(EndpointReferenceType reference, AddressingProperties inMAPs, final Message inMessage) { String namespaceURI = inMAPs.getNamespaceURI(); - if (!retrievePartialResponseSent(inMessage)) { - storePartialResponseSent(inMessage); + if (!ContextUtils.retrievePartialResponseSent(inMessage)) { + ContextUtils.storePartialResponseSent(inMessage); Exchange exchange = inMessage.getExchange(); Message fullResponse = exchange.getOutMessage(); - Message partialResponse = createMessage(exchange); + Message partialResponse = ContextUtils.createMessage(exchange); ensurePartialResponseMAPs(partialResponse, namespaceURI); // ensure the inbound MAPs are available in the partial response // message (used to determine relatesTo etc.) - propogateReceivedMAPs(inMAPs, partialResponse); - partialResponse.put(Message.PARTIAL_RESPONSE_MESSAGE, Boolean.TRUE); + ContextUtils.propogateReceivedMAPs(inMAPs, partialResponse); Destination target = inMessage.getDestination(); if (target == null) { return; @@ -400,7 +401,67 @@ Conduit backChannel = target.getBackChannel(inMessage, partialResponse, reference); + Exception exception = inMessage.getContent(Exception.class); + //Add this to handle two way faultTo + //TODO:Look at how to refactor + if (backChannel != null && !inMessage.getExchange().isOneWay() + && ContextUtils.isFault(inMessage)) { + // send the fault message to faultTo Endpoint + exchange.setOutMessage(ContextUtils.createMessage(exchange)); + exchange.put(ConduitSelector.class, new NullConduitSelector()); + exchange.put("org.apache.cxf.http.no_io_exceptions", true); + Destination destination = createDecoupledDestination(exchange, reference); + exchange.setDestination(destination); + + if (ContextUtils.retrieveAsyncPostResponseDispatch(inMessage)) { + DelegatingInputStream in = inMessage.getContent(DelegatingInputStream.class); + if (in != null) { + in.cacheInput(); + } + inMessage.getInterceptorChain().reset(); + //cleanup pathinfo + if (inMessage.get(Message.PATH_INFO) != null) { + inMessage.remove(Message.PATH_INFO); + } + inMessage.getInterceptorChain().doIntercept(inMessage); + + } + + // send the partial response to requester + partialResponse.put("forced.faultstring", + "The server sent HTTP status code :" + + inMessage.getExchange().get(Message.RESPONSE_CODE)); + partialResponse.setContent(Exception.class, exception); + partialResponse.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, + inMessage.get(Message.PROTOCOL_HEADERS)); + partialResponse.put(org.apache.cxf.message.Message.ENCODING, + inMessage.get(Message.ENCODING)); + partialResponse.put(ContextUtils.ACTION, inMessage.get(ContextUtils.ACTION)); + partialResponse.put("javax.xml.ws.addressing.context.inbound", + inMessage.get("javax.xml.ws.addressing.context.inbound")); + partialResponse.put("javax.xml.ws.addressing.context.outbound", + inMessage.get("javax.xml.ws.addressing.context.outbound")); + exchange.setOutMessage(partialResponse); + PhaseInterceptorChain newChian = ((PhaseInterceptorChain)inMessage.getInterceptorChain()) + .cloneChain(); + partialResponse.setInterceptorChain(newChian); + exchange.setDestination(target); + exchange.setOneWay(false); + exchange.put(ConduitSelector.class, + new PreexistingConduitSelector(backChannel, exchange.get(Endpoint.class))); + if (newChian != null && !newChian.doIntercept(partialResponse) + && partialResponse.getContent(Exception.class) != null) { + if (partialResponse.getContent(Exception.class) instanceof Fault) { + throw (Fault)partialResponse.getContent(Exception.class); + } else { + throw new Fault(partialResponse.getContent(Exception.class)); + } + } + return; + } + if (backChannel != null) { + partialResponse.put(Message.PARTIAL_RESPONSE_MESSAGE, Boolean.TRUE); boolean robust = MessageUtils.isTrue(inMessage.getContextualProperty(Message.ROBUST_ONEWAY)); @@ -422,12 +483,13 @@ exchange.put(BindingOperationInfo.class, boi); } + // set up interceptor chains and send message InterceptorChain chain = fullResponse != null ? fullResponse.getInterceptorChain() : OutgoingChainInterceptor.getOutInterceptorChain(exchange); - exchange.setOutMessage(partialResponse); + exchange.setOutMessage(partialResponse); partialResponse.setInterceptorChain(chain); exchange.put(ConduitSelector.class, new PreexistingConduitSelector(backChannel, @@ -447,7 +509,7 @@ exchange.put(ConduitSelector.class, new NullConduitSelector()); if (fullResponse == null) { - fullResponse = createMessage(exchange); + fullResponse = ContextUtils.createMessage(exchange); } exchange.setOutMessage(fullResponse); @@ -457,7 +519,7 @@ exchange.setDestination(destination); - if (retrieveAsyncPostResponseDispatch(inMessage)) { + if (ContextUtils.retrieveAsyncPostResponseDispatch(inMessage) && !robust) { //need to suck in all the data from the input stream as //the transport might discard any data on the stream when this //thread unwinds or when the empty response is sent back @@ -465,24 +527,25 @@ if (in != null) { in.cacheInput(); } - try { - if (!robust) { - // async service invocation required *after* a response - // has been sent (i.e. to a oneway, or a partial response - // to a decoupled twoway) - - // pause dispatch on current thread ... - inMessage.getInterceptorChain().pause(); + // async service invocation required *after* a response + // has been sent (i.e. to a oneway, or a partial response + // to a decoupled twoway) + + //cleanup pathinfo + if (inMessage.get(Message.PATH_INFO) != null) { + inMessage.remove(Message.PATH_INFO); + } + // pause dispatch on current thread ... + inMessage.getInterceptorChain().pause(); - - // ... and resume on executor thread - getExecutor(inMessage).execute(new Runnable() { - public void run() { - inMessage.getInterceptorChain().resume(); - } - }); - } + try { + // ... and resume on executor thread + getExecutor(inMessage).execute(new Runnable() { + public void run() { + inMessage.getInterceptorChain().resume(); + } + }); } catch (RejectedExecutionException e) { LOG.warning( "Executor queue is full, use the caller thread." @@ -496,13 +559,13 @@ } } } - } + } } catch (Exception e) { LOG.log(Level.WARNING, "SERVER_TRANSPORT_REBASE_FAILURE_MSG", e); } } } - + //CHECKSTYLE:ON public static Destination createDecoupledDestination( Exchange exchange, final EndpointReferenceType reference) { Added: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandler.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandler.java (rev 0) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandler.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -0,0 +1,99 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.cxf.ws.addressing.soap; + +import java.util.Iterator; + +import org.apache.cxf.binding.soap.SoapMessage; +import org.apache.cxf.binding.soap.interceptor.AbstractSoapInterceptor; +import org.apache.cxf.headers.Header; +import org.apache.cxf.message.Exchange; +import org.apache.cxf.message.Message; +import org.apache.cxf.phase.Phase; +import org.apache.cxf.transport.Destination; +import org.apache.cxf.ws.addressing.AddressingProperties; +import org.apache.cxf.ws.addressing.ContextUtils; +import org.apache.cxf.ws.addressing.EndpointReferenceType; +import org.apache.cxf.ws.addressing.Names; + +/** + * Utility interceptor for dealing with faults occurred during processing + * the one way requests with WSA FaultTo EPR pointing to a decoupled destination. + * + * Note that this interceptor is not currently installed by default. + * It can be installed using @InInterceptors and @OutInterceptors + * annotations or explicitly added to the list of interceptors. + */ +public class DecoupledFaultHandler extends AbstractSoapInterceptor { + + public static final String WSA_ACTION = "http://schemas.xmlsoap.org/wsdl/soap/envelope/fault"; + + public DecoupledFaultHandler() { + super(Phase.PRE_PROTOCOL); + addBefore(MAPCodec.class.getName()); + } + + public void handleMessage(SoapMessage message) { + // complete + } + + // Ideally, this code will instead be executed as part of the Fault chain + // but at the moment PhaseInterceptorChain needs to be tricked that this is + // a two way request for a fault chain be invoked + public void handleFault(SoapMessage message) { + if (!ContextUtils.isRequestor(message)) { + + Exchange exchange = message.getExchange(); + Message inMessage = exchange.getInMessage(); + final AddressingProperties maps = + ContextUtils.retrieveMAPs(inMessage, false, false, true); + + if (maps != null && !ContextUtils.isGenericAddress(maps.getFaultTo())) { + //Just keep the wsa headers to remove the not understand headers + Iterator<Header> iterator = message.getHeaders().iterator(); + while (iterator.hasNext()) { + Header header = iterator.next(); + if (!isWSAHeader(header)) { + iterator.remove(); + } + } + exchange.setOneWay(false); + exchange.setOutMessage(message); + //manually set the action + message.put(ContextUtils.ACTION, WSA_ACTION); + Destination destination = createDecoupledDestination( + exchange, maps.getFaultTo()); + exchange.setDestination(destination); + } + + } + } + + protected Destination createDecoupledDestination(Exchange exchange, EndpointReferenceType epr) { + return ContextUtils.createDecoupledDestination(exchange, epr); + } + + private boolean isWSAHeader(Header header) { + if (header.getName().getNamespaceURI().startsWith(Names.WSA_NAMESPACE_NAME)) { + return true; + } + return false; + } +} Modified: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/MAPCodec.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/MAPCodec.java 2012-08-09 07:52:21 UTC (rev 16585) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/MAPCodec.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -78,8 +78,8 @@ private static final Logger LOG = LogUtils.getL7dLogger(MAPCodec.class); private static final String IS_REFERENCE_PARAM_ATTR_NAME = "IsReferenceParameter"; private static final ResourceBundle BUNDLE = LOG.getResourceBundle(); - private static final String ONE_WAY_DECOUPLED_FAULT_SUPPORT = - "org.apache.cxf.ws.addressing.oneway.decoupled_fault_support"; + private static final String DECOUPLED_FAULT_SUPPORT = + "org.apache.cxf.ws.addressing.decoupled_fault_support"; /** * REVISIT: map usage that the *same* interceptor instance @@ -152,9 +152,9 @@ } } } else if (MessageUtils.getContextualBoolean(message, - ONE_WAY_DECOUPLED_FAULT_SUPPORT, + DECOUPLED_FAULT_SUPPORT, false)) { - new OneWayDecoupledFaultHandler().handleFault(message); + new DecoupledFaultHandler().handleFault(message); } } Deleted: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandler.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandler.java 2012-08-09 07:52:21 UTC (rev 16585) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/main/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandler.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -1,100 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ - -package org.apache.cxf.ws.addressing.soap; - -import java.util.Iterator; - -import org.apache.cxf.binding.soap.SoapMessage; -import org.apache.cxf.binding.soap.interceptor.AbstractSoapInterceptor; -import org.apache.cxf.headers.Header; -import org.apache.cxf.message.Exchange; -import org.apache.cxf.message.Message; -import org.apache.cxf.phase.Phase; -import org.apache.cxf.transport.Destination; -import org.apache.cxf.ws.addressing.AddressingPropertiesImpl; -import org.apache.cxf.ws.addressing.ContextUtils; -import org.apache.cxf.ws.addressing.EndpointReferenceType; -import org.apache.cxf.ws.addressing.Names; - -/** - * Utility interceptor for dealing with faults occurred during processing - * the one way requests with WSA FaultTo EPR pointing to a decoupled destination. - * - * Note that this interceptor is not currently installed by default. - * It can be installed using @InInterceptors and @OutInterceptors - * annotations or explicitly added to the list of interceptors. - */ -public class OneWayDecoupledFaultHandler extends AbstractSoapInterceptor { - - public static final String WSA_ACTION = "http://schemas.xmlsoap.org/wsdl/soap/envelope/fault"; - - public OneWayDecoupledFaultHandler() { - super(Phase.PRE_PROTOCOL); - addBefore(MAPCodec.class.getName()); - } - - public void handleMessage(SoapMessage message) { - // complete - } - - // Ideally, this code will instead be executed as part of the Fault chain - // but at the moment PhaseInterceptorChain needs to be tricked that this is - // a two way request for a fault chain be invoked - public void handleFault(SoapMessage message) { - if (message.getExchange().isOneWay() - && !ContextUtils.isRequestor(message)) { - - Exchange exchange = message.getExchange(); - Message inMessage = exchange.getInMessage(); - final AddressingPropertiesImpl maps = - ContextUtils.retrieveMAPs(inMessage, false, false, true); - - if (maps != null && !ContextUtils.isGenericAddress(maps.getFaultTo())) { - //Just keep the wsa headers to remove the not understand headers - Iterator<Header> iterator = message.getHeaders().iterator(); - while (iterator.hasNext()) { - Header header = iterator.next(); - if (!isWSAHeader(header)) { - iterator.remove(); - } - } - exchange.setOneWay(false); - exchange.setOutMessage(message); - //manually set the action - message.put(ContextUtils.ACTION, WSA_ACTION); - Destination destination = createDecoupledDestination( - exchange, maps.getFaultTo()); - exchange.setDestination(destination); - } - - } - } - - protected Destination createDecoupledDestination(Exchange exchange, EndpointReferenceType epr) { - return ContextUtils.createDecoupledDestination(exchange, epr); - } - - private boolean isWSAHeader(Header header) { - if (header.getName().getNamespaceURI().startsWith(Names.WSA_NAMESPACE_NAME)) { - return true; - } - return false; - } -} Added: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandlerTest.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandlerTest.java (rev 0) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/DecoupledFaultHandlerTest.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -0,0 +1,73 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.cxf.ws.addressing.soap; + +import javax.xml.namespace.QName; + +import org.apache.cxf.binding.soap.SoapMessage; +import org.apache.cxf.headers.Header; +import org.apache.cxf.message.Exchange; +import org.apache.cxf.message.ExchangeImpl; +import org.apache.cxf.message.MessageImpl; +import org.apache.cxf.transport.Destination; +import org.apache.cxf.ws.addressing.AddressingProperties; +import org.apache.cxf.ws.addressing.AddressingPropertiesImpl; +import org.apache.cxf.ws.addressing.AttributedURIType; +import org.apache.cxf.ws.addressing.ContextUtils; +import org.apache.cxf.ws.addressing.EndpointReferenceType; +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Test; + +public class DecoupledFaultHandlerTest extends Assert { + + @Test + public void testOnewayFault() { + DecoupledFaultHandler handler = new DecoupledFaultHandler() { + protected Destination createDecoupledDestination(Exchange exchange, EndpointReferenceType epr) { + assertEquals("http://bar", epr.getAddress().getValue()); + return EasyMock.createMock(Destination.class); + } + }; + + SoapMessage message = new SoapMessage(new MessageImpl()); + QName qname = new QName("http://cxf.apache.org/mustunderstand";, "TestMU"); + message.getHeaders().add(new Header(qname, new Object())); + AddressingProperties maps = new AddressingPropertiesImpl(); + + EndpointReferenceType faultTo = new EndpointReferenceType(); + faultTo.setAddress(new AttributedURIType()); + faultTo.getAddress().setValue("http://bar"); + maps.setFaultTo(faultTo); + message.put(ContextUtils.getMAPProperty(false, false, false), + maps); + + Exchange exchange = new ExchangeImpl(); + message.setExchange(exchange); + exchange.setInMessage(message); + exchange.setOneWay(true); + + handler.handleFault(message); + assertTrue(message.getHeaders().isEmpty()); + assertFalse(exchange.isOneWay()); + assertSame(message, exchange.getOutMessage()); + assertNotNull(exchange.getDestination()); + } + +} Deleted: thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandlerTest.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandlerTest.java 2012-08-09 07:52:21 UTC (rev 16585) +++ thirdparty/cxf/branches/cxf-2.4.8/rt/ws/addr/src/test/java/org/apache/cxf/ws/addressing/soap/OneWayDecoupledFaultHandlerTest.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -1,73 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.apache.cxf.ws.addressing.soap; - -import javax.xml.namespace.QName; - -import org.apache.cxf.binding.soap.SoapMessage; -import org.apache.cxf.headers.Header; -import org.apache.cxf.message.Exchange; -import org.apache.cxf.message.ExchangeImpl; -import org.apache.cxf.message.MessageImpl; -import org.apache.cxf.transport.Destination; -import org.apache.cxf.ws.addressing.AddressingProperties; -import org.apache.cxf.ws.addressing.AddressingPropertiesImpl; -import org.apache.cxf.ws.addressing.AttributedURIType; -import org.apache.cxf.ws.addressing.ContextUtils; -import org.apache.cxf.ws.addressing.EndpointReferenceType; -import org.easymock.EasyMock; -import org.junit.Assert; -import org.junit.Test; - -public class OneWayDecoupledFaultHandlerTest extends Assert { - - @Test - public void testOnewayFault() { - OneWayDecoupledFaultHandler handler = new OneWayDecoupledFaultHandler() { - protected Destination createDecoupledDestination(Exchange exchange, EndpointReferenceType epr) { - assertEquals("http://bar", epr.getAddress().getValue()); - return EasyMock.createMock(Destination.class); - } - }; - - SoapMessage message = new SoapMessage(new MessageImpl()); - QName qname = new QName("http://cxf.apache.org/mustunderstand";, "TestMU"); - message.getHeaders().add(new Header(qname, new Object())); - AddressingProperties maps = new AddressingPropertiesImpl(); - - EndpointReferenceType faultTo = new EndpointReferenceType(); - faultTo.setAddress(new AttributedURIType()); - faultTo.getAddress().setValue("http://bar"); - maps.setFaultTo(faultTo); - message.put(ContextUtils.getMAPProperty(false, false, false), - maps); - - Exchange exchange = new ExchangeImpl(); - message.setExchange(exchange); - exchange.setInMessage(message); - exchange.setOneWay(true); - - handler.handleFault(message); - assertTrue(message.getHeaders().isEmpty()); - assertFalse(exchange.isOneWay()); - assertSame(message, exchange.getOutMessage()); - assertNotNull(exchange.getDestination()); - } - -} Added: thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/FaultToEndpointServer.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/FaultToEndpointServer.java (rev 0) +++ thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/FaultToEndpointServer.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -0,0 +1,238 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.cxf.systest.ws.addr_feature; + +import java.io.IOException; +import java.util.concurrent.Future; + +import javax.jws.WebService; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.xml.ws.AsyncHandler; +import javax.xml.ws.Endpoint; +import javax.xml.ws.Response; +import javax.xml.ws.soap.Addressing; + +import org.apache.cxf.BusFactory; +import org.apache.cxf.jaxws.EndpointImpl; +import org.apache.cxf.testutil.common.AbstractBusTestServerBase; +import org.apache.cxf.ws.addressing.WSAddressingFeature; +import org.apache.cxf.ws.addressing.soap.DecoupledFaultHandler; +import org.apache.hello_world_soap_http.BadRecordLitFault; +import org.apache.hello_world_soap_http.Greeter; +import org.apache.hello_world_soap_http.NoSuchCodeLitFault; +import org.apache.hello_world_soap_http.types.BareDocumentResponse; +import org.apache.hello_world_soap_http.types.GreetMeLaterResponse; +import org.apache.hello_world_soap_http.types.GreetMeResponse; +import org.apache.hello_world_soap_http.types.GreetMeSometimeResponse; +import org.apache.hello_world_soap_http.types.SayHiResponse; +import org.apache.hello_world_soap_http.types.TestDocLitFaultResponse; +import org.apache.hello_world_soap_http.types.TestNillableResponse; +import org.eclipse.jetty.server.Request; +import org.eclipse.jetty.server.handler.AbstractHandler; + +public class FaultToEndpointServer extends AbstractBusTestServerBase { + static final String FAULT_PORT = allocatePort(FaultToEndpointServer.class); + static final String PORT = allocatePort(FaultToEndpointServer.class, 1); + + EndpointImpl ep; + private org.eclipse.jetty.server.Server faultToserver; + protected void run() { + faultToserver = new org.eclipse.jetty.server.Server(Integer.parseInt(FAULT_PORT)); + faultToserver.setHandler(new HelloHandler()); + try { + faultToserver.start(); + } catch (Exception e) { + e.printStackTrace(); + } + + + setBus(BusFactory.getDefaultBus()); + Object implementor = new AddNumberImpl(); + String address = "http://localhost:" + PORT + "/jaxws/add"; + + ep = (EndpointImpl) Endpoint.create(implementor); + ep.getInInterceptors().add(new DecoupledFaultHandler()); + ep.getFeatures().add(new WSAddressingFeature()); + ep.publish(address); + + Object implementor2 = new GreeterImpl(); + String address2 = "http://localhost:" + PORT + "/jaxws/greeter"; + ep = (EndpointImpl) Endpoint.create(implementor2); + ep.getInInterceptors().add(new DecoupledFaultHandler()); + ep.getFeatures().add(new WSAddressingFeature()); + ep.publish(address2); + } + + public void tearDown() throws Exception { + if (faultToserver != null) { + faultToserver.stop(); + faultToserver.destroy(); + faultToserver = null; + } + + ep.stop(); + ep = null; + } + + public static void main(String[] args) { + try { + FaultToEndpointServer server = new FaultToEndpointServer(); + server.start(); + } catch (Exception ex) { + ex.printStackTrace(); + System.exit(-1); + } finally { + System.out.println("done!"); + } + } + + + + + public static class HelloHandler extends AbstractHandler { + private static String faultRequestPath; + + public void handle(String target, Request baseRequest, HttpServletRequest request, + HttpServletResponse response) throws IOException, ServletException { + response.setContentType("text/html;charset=utf-8"); + faultRequestPath = request.getPathInfo(); + if ("/faultTo".equals(faultRequestPath)) { + response.setStatus(HttpServletResponse.SC_OK); + } else { + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + } + baseRequest.setHandled(true); + response.getWriter().println("Received"); + } + + public static String getFaultRequestPath() { + return faultRequestPath; + } + + } + + @WebService(serviceName = "SOAPServiceAddressing", + portName = "SoapPort", + endpointInterface = "org.apache.hello_world_soap_http.Greeter", + targetNamespace = "http://apache.org/hello_world_soap_http", + wsdlLocation = "testutils/hello_world.wsdl") + @Addressing + public class GreeterImpl implements Greeter { + + public String greetMe(String me) { + return "Hello " + me; + } + + public String greetMeLater(long delay) { + if (delay > 0) { + try { + Thread.sleep(delay); + } catch (InterruptedException ex) { + // ignore + } + } + return "Hello, finally"; + } + + public void greetMeOneWay(String requestType) { + throw new RuntimeException("intended error"); + } + + public String sayHi() { + return null; + } + + public void testDocLitFault(String faultType) throws BadRecordLitFault, NoSuchCodeLitFault { + } + + public BareDocumentResponse testDocLitBare(String in) { + return null; + } + + public String greetMeSometime(String me) { + return null; + } + + public Future<?> greetMeSometimeAsync(String requestType, + AsyncHandler<GreetMeSometimeResponse> asyncHandler) { + return null; + } + + public Response<GreetMeSometimeResponse> greetMeSometimeAsync(String requestType) { + return null; + } + + public Response<TestDocLitFaultResponse> testDocLitFaultAsync(String faultType) { + return null; + } + + public Response<BareDocumentResponse> testDocLitBareAsync(String bare) { + return null; + } + + public Future<?> greetMeAsync(String requestType, AsyncHandler<GreetMeResponse> asyncHandler) { + return null; + } + + public Response<GreetMeResponse> greetMeAsync(String requestType) { + return null; + } + + public Future<?> greetMeLaterAsync(long requestType, AsyncHandler<GreetMeLaterResponse> asyncHandler) { + return null; + } + + public Response<GreetMeLaterResponse> greetMeLaterAsync(long requestType) { + return null; + } + + public Future<?> sayHiAsync(AsyncHandler<SayHiResponse> asyncHandler) { + return null; + } + + public Response<SayHiResponse> sayHiAsync() { + return null; + } + + public String testNillable(String nillElem, int intElem) { + return null; + } + + public Response<TestNillableResponse> testNillableAsync(String nillElem, + int intElem) { + return null; + } + + public Future<?> testNillableAsync(String nillElem, + int intElem, + AsyncHandler<TestNillableResponse> asyncHandler) { + return null; + } + + public Future<?> testDocLitFaultAsync(String faultType, + AsyncHandler<TestDocLitFaultResponse> asyncHandler) { + return null; + } + + } +} + + Added: thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/WSAFaultToClientServerTest.java =================================================================== --- thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/WSAFaultToClientServerTest.java (rev 0) +++ thirdparty/cxf/branches/cxf-2.4.8/systests/ws-specs/src/test/java/org/apache/cxf/systest/ws/addr_feature/WSAFaultToClientServerTest.java 2012-08-09 15:41:46 UTC (rev 16586) @@ -0,0 +1,132 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.cxf.systest.ws.addr_feature; + +import java.io.ByteArrayOutputStream; +import java.net.URL; +import java.util.Map; + +import javax.xml.namespace.QName; +import javax.xml.ws.BindingProvider; +import javax.xml.ws.soap.AddressingFeature; + +import org.apache.cxf.systest.ws.AbstractWSATestBase; +import org.apache.cxf.systest.ws.addr_feature.FaultToEndpointServer.HelloHandler; +import org.apache.cxf.ws.addressing.AddressingProperties; +import org.apache.cxf.ws.addressing.AddressingPropertiesImpl; +import org.apache.cxf.ws.addressing.AttributedURIType; +import org.apache.cxf.ws.addressing.EndpointReferenceType; +import org.apache.cxf.ws.addressing.JAXWSAConstants; +import org.apache.hello_world_soap_http.Greeter; +import org.apache.hello_world_soap_http.SOAPService; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +public class WSAFaultToClientServerTest extends AbstractWSATestBase { + + @Before + public void setUp() throws Exception { + createBus(); + } + + @BeforeClass + public static void startServers() throws Exception { + assertTrue("FaultTo server did not launch correctly", launchServer(FaultToEndpointServer.class, true)); + } + + @Test + public void testOneWayFaultTo() throws Exception { + URL wsdl = getClass().getResource("/wsdl/hello_world.wsdl"); + QName serviceName = new QName("http://apache.org/hello_world_soap_http";, "SOAPServiceAddressing"); + + Greeter greeter = new SOAPService(wsdl, serviceName).getPort(Greeter.class, new AddressingFeature()); + EndpointReferenceType faultTo = new EndpointReferenceType(); + AddressingProperties addrProperties = new AddressingPropertiesImpl(); + AttributedURIType epr = new AttributedURIType(); + String faultToAddress = "http://localhost:" + FaultToEndpointServer.FAULT_PORT + "/faultTo"; + epr.setValue(faultToAddress); + faultTo.setAddress(epr); + addrProperties.setFaultTo(faultTo); + + BindingProvider provider = (BindingProvider) greeter; + Map<String, Object> requestContext = provider.getRequestContext(); + requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, + "http://localhost:" + FaultToEndpointServer.PORT + "/jaxws/greeter"); + requestContext.put(JAXWSAConstants.CLIENT_ADDRESSING_PROPERTIES, addrProperties); + + greeter.greetMeOneWay("test"); + //wait for the fault request + int i = 2; + while (HelloHandler.getFaultRequestPath() == null && i > 0) { + Thread.sleep(500); + i--; + } + assertTrue("FaultTo request fpath isn't expected", + "/faultTo".equals(HelloHandler.getFaultRequestPath())); + } + + @Test + public void testTwoWayFaultTo() throws Exception { + ByteArrayOutputStream input = setupInLogging(); + AddNumbersPortType port = getTwoWayPort(); + + EndpointReferenceType faultTo = new EndpointReferenceType(); + AddressingProperties addrProperties = new AddressingPropertiesImpl(); + AttributedURIType epr = new AttributedURIType(); + epr.setValue("http://localhost:" + FaultToEndpointServer.FAULT_PORT + "/faultTo"); + faultTo.setAddress(epr); + addrProperties.setFaultTo(faultTo); + + BindingProvider provider = (BindingProvider) port; + Map<String, Object> requestContext = provider.getRequestContext(); + requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, + "http://localhost:" + FaultToEndpointServer.PORT + "/jaxws/add"); + requestContext.put(JAXWSAConstants.CLIENT_ADDRESSING_PROPERTIES, addrProperties); + + try { + port.addNumbers(-1, -2); + fail("Exception is expected"); + } catch (Exception e) { + //do nothing + } + + assertTrue("The response from faultTo endpoint is expected and actual response is " + + new String(input.toByteArray()) , + new String(input.toByteArray()).indexOf("The server sent HTTP status code :200") > -1); + assertTrue("WS addressing header is expected", + new String(input.toByteArray()).indexOf("http://www.w3.org/2005/08/addre... > -1); + assertTrue("Fault deatil is expected", + new String(input.toByteArray()).indexOf("Negative numbers cant be added") > -1); + } + + private AddNumbersPortType getTwoWayPort() throws Exception { + URL wsdl = getClass().getResource("/wsdl_systest_wsspec/add_numbers.wsdl"); + assertNotNull("WSDL is null", wsdl); + QName serviceName = new QName("http://apache.org/cxf/systest/ws/addr_feature/";, "AddNumbersService"); + AddNumbersService service = new AddNumbersService(wsdl, serviceName); + assertNotNull("Service is null ", service); + AddNumbersPortType port = service.getAddNumbersPort(new AddressingFeature()); + //updateAddressPort(port, PORT); + return port; + } + + +}