/** * Get MessageId from WS Addressing properties * * @param message * @return message id */ private String getMessageId(Message message) { AddressingProperties addrProp = ContextUtils.retrieveMAPs(message, false, MessageUtils.isOutbound(message), false); return addrProp != null && addrProp.getMessageID() != null ? addrProp.getMessageID().getValue() : UUID.randomUUID().toString(); }
private boolean isNativeAsyn(Message message) { boolean ret = false; AddressingProperties addressingProperties = (AddressingProperties) message.get(WSAUtils.WSA_HEADERS_INBOUND); if (addressingProperties != null && !ContextUtils.isGenericAddress(addressingProperties.getReplyTo())) { //it's decoupled endpoint, so already switch thread and //use executors, which means underlying transport won't //be block, so we shouldn't rely on continuation in //this case, as the SuspendedInvocationException can't be //caught by underlying transport. We just need pause/resume InterceptorChain //before/after send/receive MessageExchange for async return true; } return ret; }
/** * Cache exchange for correlated response * * @param message the current message * @param maps the addressing properties */ private void cacheExchange(SoapMessage message, AddressingProperties maps) { if (ContextUtils.isRequestor(message) && !message.getExchange().isOneWay()) { uncorrelatedExchanges.put(maps.getMessageID().getValue(), message.getExchange()); } }
private boolean isWSAddressingReplyToSpecified(Exchange ex) { AddressingProperties map = ContextUtils.retrieveMAPs(ex.getInMessage(), false, false, false); return map != null && !ContextUtils.isGenericAddress(map.getReplyTo()); } };
/** * Store MAPs in the message. * * @param message the current message * @param isOutbound true if the message is outbound */ public static void storeMAPs(AddressingProperties maps, Message message, boolean isOutbound) { storeMAPs(maps, message, isOutbound, isRequestor(message), false); }
/** * check if MessageID exists in the message, if not, only generate new MessageID for outbound message. * @param message */ private void checkMessageID(Message message) { if (!MessageUtils.isOutbound(message)) return; AddressingProperties maps = ContextUtils.retrieveMAPs(message, false, MessageUtils.isOutbound(message)); if (maps == null) { maps = new AddressingProperties(); } if (maps.getMessageID() == null) { String messageID = ContextUtils.generateUUID(); boolean isRequestor = ContextUtils.isRequestor(message); maps.setMessageID(ContextUtils.getAttributedURI(messageID)); ContextUtils.storeMAPs(maps, message, ContextUtils.isOutbound(message), isRequestor); } }
String namespaceURI = inMAPs.getNamespaceURI(); if (!ContextUtils.retrievePartialResponseSent(inMessage)) { ContextUtils.storePartialResponseSent(inMessage); Exchange exchange = inMessage.getExchange(); Message fullResponse = exchange.getOutMessage(); Message partialResponse = ContextUtils.createMessage(exchange); ensurePartialResponseMAPs(partialResponse, namespaceURI); ContextUtils.propogateReceivedMAPs(inMAPs, partialResponse); Destination target = inMessage.getDestination(); if (target == null) { return; reference = ContextUtils.getNoneEndpointReference(); if (backChannel != null && !inMessage.getExchange().isOneWay() && ContextUtils.isFault(inMessage)) { exchange.setOutMessage(ContextUtils.createMessage(exchange)); if (ContextUtils.retrieveAsyncPostResponseDispatch(inMessage)) { if (ContextUtils.retrieveAsyncPostResponseDispatch(inMessage) && !robust) { fullResponse = ContextUtils.createMessage(exchange); if (ContextUtils.retrieveAsyncPostResponseDispatch(inMessage) && !robust) {
if (ContextUtils.isOutbound(message)) { if (usingAddressing(message)) { ContextUtils.retrieveMAPs(message, false, ContextUtils.isOutbound(message)); if (isAddressingRequired() && ContextUtils.isRequestor(message)) { theMaps.setRequired(true); if (ContextUtils.isRequestor(message)) { assertAddressing(message, theMaps.getReplyTo(), theMaps.getFaultTo()); } else { checkReplyTo(message, theMaps); } else if (!ContextUtils.isRequestor(message)) { if (maps != null) { AddressingProperties theMaps = ContextUtils.retrieveMAPs(message, false, ContextUtils.isOutbound(message)); || !ContextUtils.isGenericAddress(maps.getReplyTo())) { if (ContextUtils.isNoneAddress(maps.getReplyTo())) { LOG.warning("Detected NONE value in ReplyTo WSA header for request-respone MEP"); } else { ContextUtils.propogateReceivedMAPs(maps, message.getExchange());
final Message inMessage) { String namespaceURI = inMAPs.getNamespaceURI(); if (!ContextUtils.retrievePartialResponseSent(inMessage)) { ContextUtils.storePartialResponseSent(inMessage); Exchange exchange = inMessage.getExchange(); Message fullResponse = exchange.getOutMessage(); Message partialResponse = ContextUtils.createMessage(exchange); ensurePartialResponseMAPs(partialResponse, namespaceURI); ContextUtils.propogateReceivedMAPs(inMAPs, partialResponse); Destination target = inMessage.getDestination(); if (target == null) { return; reference = ContextUtils.getNoneEndpointReference(); BindingOperationInfo boi = exchange.getBindingOperationInfo(); exchange.put(Executor.class, getExecutor(inMessage)); inMessage.getInterceptorChain().pause(); fullResponse = ContextUtils.createMessage(exchange); exchange.setOutMessage(fullResponse);
protected void handle(Message msg) throws SequenceFault, RMException { AddressingProperties maps = ContextUtils.retrieveMAPs(msg, false, true, false); if (null == maps) { LogUtils.log(LOG, Level.WARNING, "MAPS_RETRIEVAL_FAILURE_MSG"); return; if (Boolean.TRUE.equals(msg.get(RMMessageConstants.RM_RETRANSMISSION))) { return; Throwable cause = msg.getContent(Exception.class).getCause(); if (cause instanceof SequenceFault || cause instanceof RMException) { maps.getAction().setValue(getAddressingNamespace(maps) + "/fault"); ProtocolVariation protocol = ProtocolVariation.findVariant(rmNamespace, wsaNamespace); RMContextUtils.setProtocolVariation(msg, protocol); maps.exposeAs(wsaNamespace); if (null != maps.getAction()) { action = maps.getAction().getValue(); if (msg.getExchange().isOneWay()) { msg.getExchange().put(Message.PROCESS_ONEWAY_RESPONSE, true); inMessageNumber = rmpsIn.getSequence().getMessageNumber(); ContextUtils.storeDeferUncorrelatedMessageAbort(msg);
boolean isOneway = exchange.isOneWay(); boolean isOutbound = ContextUtils.isOutbound(message); if (maps.getTo() == null) { Conduit conduit = null; if (isOutbound) { conduit = ContextUtils.getConduit(null, message); String s = (String)message.get(Message.ENDPOINT_ADDRESS); EndpointReferenceType reference = conduit != null ? conduit.getTarget() : ContextUtils.getNoneEndpointReference(); if (conduit != null && !StringUtils.isEmpty(s) && !reference.getAddress().getValue().equals(s)) { EndpointReferenceType ref = new EndpointReferenceType(); AttributedURIType tp = new AttributedURIType(); tp.setValue(s); ref.setAddress(tp); ref.setMetadata(reference.getMetadata()); EndpointReferenceType replyTo = maps.getReplyTo(); if (ContextUtils.isGenericAddress(replyTo)) { replyTo = getReplyTo(message, replyTo); if (replyTo == null || (isOneway ContextUtils.getAttributedURI(isOneway ? Names.WSA_NONE_ADDRESS : Names.WSA_ANONYMOUS_ADDRESS);
boolean isOutbound, boolean warnIfMissing) { boolean isRequestor = ContextUtils.isRequestor(message); String mapProperty = ContextUtils.getMAPProperty(isRequestor, isProviderContext, isOutbound); (AddressingProperties)message.get(mapProperty); if (maps == null && isOutbound && !isRequestor && message.getExchange() != null && message.getExchange().getInMessage() != null) { maps = (AddressingProperties)message.getExchange().getInMessage().get(mapProperty);
to = RMUtils.createReference(maps.getTo().getValue()); acksTo = maps.getReplyTo(); if (RMUtils.getAddressingConstants().getNoneURI().equals(acksTo.getAddress().getValue())) { Endpoint ei = message.getExchange().getEndpoint(); org.apache.cxf.transport.Destination dest = ei == null ? null : ei.getEndpointInfo() if (ContextUtils.isGenericAddress(to)) { org.apache.cxf.common.i18n.Message msg = new org.apache.cxf.common.i18n.Message( "CREATE_SEQ_ANON_TARGET", LOG, Exchange exchange = new ExchangeImpl(); Map<String, Object> context = new HashMap<>(16); for (String key : message.getContextualPropertyKeys()) { context.put(key, message.getContextualProperty(key)); Exchange appex = message.getExchange(); if (appex.get(SecurityConstants.TOKEN) == null) { appex.put(SecurityConstants.TOKEN, exchange.get(SecurityConstants.TOKEN)); appex.put(SecurityConstants.TOKEN_ID, exchange.get(SecurityConstants.TOKEN_ID));
@Override public void handleFault(Message message) { message.put(MAPAggregator.class.getName(), true); if (RMContextUtils.getProtocolVariation(message) != null) { if (PropertyUtils.isTrue(message.get(RMMessageConstants.DELIVERING_ROBUST_ONEWAY))) { && !PropertyUtils.isTrue(message.get(RMMessageConstants.DELIVERING_ROBUST_ONEWAY))) { Exchange exchange = message.getExchange(); exchange.setOneWay(false); final AddressingProperties maps = ContextUtils.retrieveMAPs(message, false, false, true); if (maps != null && !ContextUtils.isGenericAddress(maps.getFaultTo())) { exchange.setDestination(ContextUtils.createDecoupledDestination(exchange, maps.getFaultTo()));
final AddressingProperties maps = ContextUtils.retrieveMAPs(message, false, false, false); if (null == maps) { if (null != maps.getAction()) { action = maps.getAction().getValue(); Object originalRequestor = message.get(RMMessageConstants.ORIGINAL_REQUESTOR_ROLE); if (null != originalRequestor) { LOG.fine("Restoring original requestor role to: " + originalRequestor); message.put(Message.REQUESTOR_ROLE, originalRequestor); String addrUri = maps.getNamespaceURI(); if (null == protocol && !MessageUtils.isFault(message)) { org.apache.cxf.common.i18n.Message msg = new org.apache.cxf.common.i18n.Message( "WSRM_REQUIRED_EXC", LOG, rmUri, addrUri); processDeliveryAssurance(rmps); if (ContextUtils.retrieveDeferredUncorrelatedMessageAbort(message)) { LOG.info("deferred uncorrelated message abort"); message.getInterceptorChain().abort(); } else { rme.receivedApplicationMessage();
protected String getActionUri(Message message, boolean checkMessage) { BindingOperationInfo bop = message.getExchange().getBindingOperationInfo(); if (bop == null || Boolean.TRUE.equals(bop.getProperty("operation.is.synthetic"))) { return null; actionUri = (String) message.get(ContextUtils.ACTION); if (actionUri == null) { actionUri = (String) message.get(SoapBindingConstants.SOAP_ACTION); boolean inbound = !ContextUtils.isOutbound(message); boolean requestor = ContextUtils.isRequestor(message); boolean inMsg = requestor ^ inbound; if (ContextUtils.isFault(message)) { String faultName = getFaultNameFromMessage(message); actionUri = getActionFromFaultMessage(op, faultName);
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 if (exchange.getOutMessage() != null) { message = (SoapMessage)exchange.getOutMessage(); } 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); } } }
synchronized (correlatedExchange) { message.setExchange(correlatedExchange); } else if (ContextUtils.isRequestor(message) && !message.getExchange().isOneWay()) { if (ContextUtils.retrieveDeferUncorrelatedMessageAbort(message)) { LOG.fine("deferring uncorrelated message abort"); ContextUtils.storeDeferredUncorrelatedMessageAbort(message); } else if (!MessageUtils.getContextualBoolean(message, "org.apache.cxf.ws.addressing.MAPAggregator.addressingDisabled", false)) { Message outmsg = message.getExchange().getOutMessage(); AddressingProperties outp = outmsg != null ? ContextUtils.retrieveMAPs(outmsg, false, true, false) : null; if (outp == null || !outp.getMessageID().getValue().equals(maps.getRelatesTo().getValue())) { Message m = message.getExchange().getOutMessage(); maps = ContextUtils.retrieveMAPs(m, false, true, false); if (maps != null) { Exchange ex = uncorrelatedExchanges.get(maps.getMessageID().getValue()); if (ex == message.getExchange()) { uncorrelatedExchanges.remove(maps.getMessageID().getValue()); LOG.log(Level.WARNING, "RESPONSE_NOT_USING_WSADDRESSING"); maps = ContextUtils.retrieveMAPs(m, false, true, false);
Message reqMsg = message.getExchange().getInMessage(); if (reqMsg == null) { LOG.warning("InMessage is null!"); Exchange ex = reqMsg.getExchange(); if (ex.isOneWay()) { return; Message inMsg = ex.getInMessage(); reqFid = ContextUtils.generateUUID(); if (null != ex.getOutFaultMessage()) {
EndpointReferenceType replyTo, EndpointReferenceType faultTo) { AssertionInfoMap aim = message.get(AssertionInfoMap.class); if (null == aim) { return; faultTo = replyTo; boolean anonReply = ContextUtils.isGenericAddress(replyTo); boolean anonFault = ContextUtils.isGenericAddress(faultTo); boolean onlyAnonymous = anonReply && anonFault; boolean hasAnonymous = anonReply || anonFault; if (!MessageUtils.isRequestor(message) && !MessageUtils.isOutbound(message)) { message.put(FaultMode.class, FaultMode.UNCHECKED_APPLICATION_FAULT); if (isSOAP12(message)) { SoapFault soap12Fault = new SoapFault( new QName(Names.WSA_NAMESPACE_NAME, "OnlyNonAnonymousAddressSupported")); } else if (!onlyAnonymous && !hasNonAnon && hasAnon) { message.put(FaultMode.class, FaultMode.UNCHECKED_APPLICATION_FAULT); if (isSOAP12(message)) { SoapFault soap12Fault = new SoapFault(