Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/**
* 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;
import java.text.MessageFormat;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.xml.namespace.QName;
import javax.xml.ws.WebFault;
import org.apache.cxf.binding.soap.SoapConstants;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.common.util.StringUtils;
import org.apache.cxf.endpoint.Endpoint;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.message.Exchange;
import org.apache.cxf.message.FaultMode;
import org.apache.cxf.message.Message;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.apache.cxf.service.model.BindingOperationInfo;
import org.apache.cxf.service.model.EndpointInfo;
import org.apache.cxf.service.model.FaultInfo;
import org.apache.cxf.service.model.MessageInfo;
import org.apache.cxf.service.model.OperationInfo;
import org.apache.cxf.service.model.UnwrappedOperationInfo;
import org.apache.cxf.transport.Conduit;
import org.apache.cxf.transport.Destination;
import org.apache.cxf.ws.addressing.policy.MetadataConstants;
import org.apache.cxf.ws.policy.AssertionInfo;
import org.apache.cxf.ws.policy.AssertionInfoMap;
/**
* Logical Handler responsible for aggregating the Message Addressing
* Properties for outgoing messages.
*/
public class MAPAggregator extends AbstractPhaseInterceptor {
public static final String USING_ADDRESSING = MAPAggregator.class.getName() + ".usingAddressing";
private static final Logger LOG =
LogUtils.getL7dLogger(MAPAggregator.class);
private static final ResourceBundle BUNDLE = LOG.getResourceBundle();
/**
* REVISIT: map usage implies that the *same* interceptor instance
* is used in all chains.
*/
protected final Map messageIDs =
new ConcurrentHashMap();
private boolean usingAddressingAdvisory = true;
private boolean allowDuplicates = true;
/**
* Constructor.
*/
public MAPAggregator() {
super(Phase.PRE_LOGICAL);
}
/**
* Indicates if duplicate messageIDs are allowed.
* @return true if duplicate messageIDs are allowed
*/
public boolean allowDuplicates() {
return allowDuplicates;
}
/**
* Allows/disallows duplicate messageIdDs.
* @param ad whether duplicate messageIDs are allowed
*/
public void setAllowDuplicates(boolean ad) {
allowDuplicates = ad;
}
/**
* Whether the presence of the element
* in the WSDL is purely advisory, i.e. its absence doesn't prevent
* the encoding of WS-A headers.
*
* @return true if the presence of the element is
* advisory
*/
public boolean isUsingAddressingAdvisory() {
return usingAddressingAdvisory;
}
/**
* Controls whether the presence of the element
* in the WSDL is purely advisory, i.e. its absence doesn't prevent
* the encoding of WS-A headers.
*
* @param advisory true if the presence of the
* element is to be advisory
*/
public void setUsingAddressingAdvisory(boolean advisory) {
usingAddressingAdvisory = advisory;
}
/**
* Invoked for normal processing of inbound and outbound messages.
*
* @param message the current message
*/
public void handleMessage(Message message) {
mediate(message, ContextUtils.isFault(message));
}
/**
* Invoked when unwinding normal interceptor chain when a fault occurred.
*
* @param message the current message
*/
public void handleFault(Message message) {
}
/**
* Determine if addressing is being used
*
* @param message the current message
* @pre message is outbound
*/
private boolean usingAddressing(Message message) {
boolean ret = true;
if (ContextUtils.isRequestor(message)) {
if (hasUsingAddressing(message)
|| hasAddressingAssertion(message)
|| hasUsingAddressingAssertion(message)) {
return true;
}
if (!usingAddressingAdvisory
|| !WSAContextUtils.retrieveUsingAddressing(message)) {
ret = false;
}
} else {
ret = getMAPs(message, false, false) != null;
}
return ret;
}
/**
* Determine if the use of addressing is indicated by the presence of a
* the usingAddressing attribute.
*
* @param message the current message
* @pre message is outbound
* @pre requestor role
*/
private boolean hasUsingAddressing(Message message) {
boolean ret = false;
Endpoint endpoint = message.getExchange().get(Endpoint.class);
if (null != endpoint) {
Boolean b = (Boolean)endpoint.get(USING_ADDRESSING);
if (null == b) {
EndpointInfo endpointInfo = endpoint.getEndpointInfo();
List endpointExts = endpointInfo != null ? endpointInfo
.getExtensors(ExtensibilityElement.class) : null;
List bindingExts = endpointInfo != null
&& endpointInfo.getBinding() != null ? endpointInfo
.getBinding().getExtensors(ExtensibilityElement.class) : null;
List serviceExts = endpointInfo != null
&& endpointInfo.getService() != null ? endpointInfo
.getService().getExtensors(ExtensibilityElement.class) : null;
ret = hasUsingAddressing(endpointExts) || hasUsingAddressing(bindingExts)
|| hasUsingAddressing(serviceExts);
b = ret ? Boolean.TRUE : Boolean.FALSE;
endpoint.put(USING_ADDRESSING, b);
} else {
ret = b.booleanValue();
}
}
return ret;
}
/**
* Determine if the use of addressing is indicated by an Addressing assertion in the
* alternative chosen for the current message.
*
* @param message the current message
* @pre message is outbound
* @pre requestor role
*/
private boolean hasAddressingAssertion(Message message) {
AssertionInfoMap aim = message.get(AssertionInfoMap.class);
if (null == aim) {
return false;
}
Collection ais = aim.get(MetadataConstants.ADDRESSING_ASSERTION_QNAME);
if (null == ais || ais.size() == 0) {
return false;
}
// no need to analyse the content of the Addressing assertion here
return true;
}
/**
* Determine if the use of addressing is indicated by a UsingAddressing in the
* alternative chosen for the current message.
*
* @param message the current message
* @pre message is outbound
* @pre requestor role
*/
private boolean hasUsingAddressingAssertion(Message message) {
AssertionInfoMap aim = message.get(AssertionInfoMap.class);
if (null == aim) {
return false;
}
Collection ais = aim.get(MetadataConstants.USING_ADDRESSING_2004_QNAME);
if (null != ais && ais.size() > 0) {
return true;
}
ais = aim.get(MetadataConstants.USING_ADDRESSING_2005_QNAME);
if (null != ais && ais.size() > 0) {
return true;
}
ais = aim.get(MetadataConstants.USING_ADDRESSING_2006_QNAME);
if (null != ais && ais.size() > 0) {
return true;
}
return false;
}
/**
* Asserts all Addressing assertions for the current message, regardless their nested
* Policies.
* @param message the current message
*/
private void assertAddressing(Message message) {
AssertionInfoMap aim = message.get(AssertionInfoMap.class);
if (null == aim) {
return;
}
QName[] types = new QName[] {
MetadataConstants.ADDRESSING_ASSERTION_QNAME,
MetadataConstants.USING_ADDRESSING_2004_QNAME,
MetadataConstants.USING_ADDRESSING_2005_QNAME,
MetadataConstants.USING_ADDRESSING_2006_QNAME
};
for (QName type : types) {
Collection ais = aim.get(type);
if (null != ais) {
for (AssertionInfo ai : ais) {
ai.setAsserted(true);
}
}
}
}
/**
* @param exts list of extension elements
* @return true iff the UsingAddressing element is found
*/
private boolean hasUsingAddressing(List exts) {
boolean found = false;
if (exts != null) {
Iterator extensionElements = exts.iterator();
while (extensionElements.hasNext() && !found) {
ExtensibilityElement ext =
(ExtensibilityElement)extensionElements.next();
found = Names.WSAW_USING_ADDRESSING_QNAME.equals(ext.getElementType());
}
}
return found;
}
/**
* Mediate message flow.
*
* @param message the current message
* @param isFault true if a fault is being mediated
* @return true if processing should continue on dispatch path
*/
protected boolean mediate(Message message, boolean isFault) {
boolean continueProcessing = true;
if (ContextUtils.isOutbound(message)) {
if (usingAddressing(message)) {
// request/response MAPs must be aggregated
aggregate(message, isFault);
}
} else if (!ContextUtils.isRequestor(message)) {
// responder validates incoming MAPs
AddressingPropertiesImpl maps = getMAPs(message, false, false);
if (null == maps) {
return false;
}
boolean isOneway = message.getExchange().isOneWay();
continueProcessing = validateIncomingMAPs(maps, message);
if (continueProcessing) {
// any faults thrown from here on can be correlated with this message
message.put(FaultMode.class, FaultMode.LOGICAL_RUNTIME_FAULT);
if (isOneway
|| !ContextUtils.isGenericAddress(maps.getReplyTo())) {
ContextUtils.rebaseResponse(maps.getReplyTo(),
maps,
message);
}
if (!isOneway) {
// ensure the inbound MAPs are available in both the full & fault
// response messages (used to determine relatesTo etc.)
ContextUtils.propogateReceivedMAPs(maps,
message.getExchange());
}
} else {
// validation failure => dispatch is aborted, response MAPs
// must be aggregated
aggregate(message, isFault);
}
}
if (null != ContextUtils.retrieveMAPs(message, false, ContextUtils.isOutbound(message))) {
assertAddressing(message);
}
return continueProcessing;
}
/**
* Perform MAP aggregation.
*
* @param message the current message
* @param isFault true if a fault is being mediated
*/
private void aggregate(Message message, boolean isFault) {
AddressingPropertiesImpl maps = assembleGeneric(message);
boolean isRequestor = ContextUtils.isRequestor(message);
addRoleSpecific(maps, message, isRequestor, isFault);
// outbound property always used to store MAPs, as this handler
// aggregates only when either:
// a) message really is outbound
// b) message is currently inbound, but we are about to abort dispatch
// due to an incoming MAPs validation failure, so the dispatch
// will shortly traverse the outbound path
ContextUtils.storeMAPs(maps, message, true, isRequestor);
}
/**
* Assemble the generic MAPs (for both requests and responses).
*
* @param message the current message
* @return AddressingProperties containing the generic MAPs
*/
private AddressingPropertiesImpl assembleGeneric(Message message) {
AddressingPropertiesImpl maps = getMAPs(message, true, true);
// MessageID
if (maps.getMessageID() == null) {
String messageID = ContextUtils.generateUUID();
maps.setMessageID(ContextUtils.getAttributedURI(messageID));
}
// Action
if (ContextUtils.hasEmptyAction(maps)) {
maps.setAction(ContextUtils.getAction(message));
if (ContextUtils.hasEmptyAction(maps)
&& ContextUtils.isOutbound(message)) {
maps.setAction(ContextUtils.getAttributedURI(getActionUri(message)));
}
}
return maps;
}
private String getActionFromInputMessage(final OperationInfo operation) {
MessageInfo inputMessage = operation.getInput();
if (inputMessage.getExtensionAttributes() != null) {
QName inputAction = (QName)inputMessage.getExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME);
if (inputAction != null) {
return inputAction.getLocalPart();
}
}
return null;
}
private String getActionFromOutputMessage(final OperationInfo operation) {
MessageInfo outputMessage = operation.getOutput();
if (outputMessage != null && outputMessage.getExtensionAttributes() != null) {
QName outputAction =
(QName)outputMessage.getExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME);
if (outputAction != null) {
return outputAction.getLocalPart();
}
}
return null;
}
private boolean isSameFault(final FaultInfo faultInfo, String faultName) {
if (faultInfo.getName() == null || faultName == null) {
return false;
}
String faultInfoName = faultInfo.getName().getLocalPart();
return faultInfoName.equals(faultName)
|| faultInfoName.equals(StringUtils.uncapitalize(faultName));
}
private String getActionBaseUri(final OperationInfo operation) {
String interfaceName = operation.getInterface().getName().getLocalPart();
return addPath(operation.getName().getNamespaceURI(), interfaceName);
}
private String getActionFromFaultMessage(final OperationInfo operation, final String faultName) {
if (operation.getFaults() != null) {
for (FaultInfo faultInfo : operation.getFaults()) {
if (isSameFault(faultInfo, faultName)) {
if (faultInfo.getExtensionAttributes() != null) {
QName faultAction =
(QName)faultInfo.getExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME);
return faultAction.getLocalPart();
}
return addPath(addPath(getActionBaseUri(operation), "Fault"),
faultInfo.getName().getLocalPart());
}
}
}
return addPath(addPath(getActionBaseUri(operation), "Fault"), faultName);
}
private String getFaultNameFromMessage(final Message message) {
Exception e = message.getContent(Exception.class);
Throwable cause = e.getCause();
if (cause == null) {
cause = e;
}
if (e instanceof Fault) {
WebFault t = cause.getClass().getAnnotation(WebFault.class);
if (t != null) {
return t.name();
}
}
return cause.getClass().getSimpleName();
}
protected String getActionUri(Message message) {
BindingOperationInfo bop = message.getExchange().get(BindingOperationInfo.class);
if (bop == null) {
return null;
}
OperationInfo op = bop.getOperationInfo();
if (op.isUnwrapped()) {
op = ((UnwrappedOperationInfo)op).getWrappedOperation();
}
String actionUri = (String) message.get(SoapConstants.SOAP_ACTION);
if (actionUri != null) {
return actionUri;
}
String opNamespace = getActionBaseUri(op);
if (ContextUtils.isRequestor(message)) {
String explicitAction = getActionFromInputMessage(op);
if (explicitAction != null) {
actionUri = explicitAction;
} else if (null == op.getInputName()) {
actionUri = addPath(opNamespace, op.getName().getLocalPart() + "Request");
} else {
actionUri = addPath(opNamespace, op.getInputName());
}
} else if (ContextUtils.isFault(message)) {
String faultName = getFaultNameFromMessage(message);
actionUri = getActionFromFaultMessage(op, faultName);
} else {
String explicitAction = getActionFromOutputMessage(op);
if (explicitAction != null) {
actionUri = explicitAction;
} else if (null == op.getOutputName()) {
actionUri = addPath(opNamespace, op.getOutput().getName().getLocalPart());
} else {
actionUri = addPath(opNamespace, op.getOutputName());
}
}
return actionUri;
}
private String getDelimiter(String uri) {
if (uri.startsWith("urn")) {
return ":";
}
return "/";
}
private String addPath(String uri, String path) {
StringBuffer buffer = new StringBuffer();
buffer.append(uri);
String delimiter = getDelimiter(uri);
if (!uri.endsWith(delimiter) && !path.startsWith(delimiter)) {
buffer.append(delimiter);
}
buffer.append(path);
return buffer.toString();
}
/**
* Add MAPs which are specific to the requestor or responder role.
*
* @param maps the MAPs being assembled
* @param message the current message
* @param isRequestor true iff the current messaging role is that of
* requestor
* @param isFault true if a fault is being mediated
*/
private void addRoleSpecific(AddressingPropertiesImpl maps,
Message message,
boolean isRequestor,
boolean isFault) {
if (isRequestor) {
Exchange exchange = message.getExchange();
// add request-specific MAPs
boolean isOneway = exchange.isOneWay();
boolean isOutbound = ContextUtils.isOutbound(message);
Conduit conduit = null;
// To
if (maps.getTo() == null) {
if (isOutbound) {
conduit = ContextUtils.getConduit(conduit, message);
}
EndpointReferenceType reference = conduit != null
? conduit.getTarget()
: ContextUtils.getNoneEndpointReference();
maps.setTo(reference);
}
// ReplyTo, set if null in MAPs or if set to a generic address
// (anonymous or none) that may not be appropriate for the
// current invocation
EndpointReferenceType replyTo = maps.getReplyTo();
if (ContextUtils.isGenericAddress(replyTo)) {
conduit = ContextUtils.getConduit(conduit, message);
if (conduit != null) {
Destination backChannel = conduit.getBackChannel();
if (backChannel != null) {
replyTo = backChannel.getAddress();
}
}
if (replyTo == null
|| (isOneway
&& (replyTo.getAddress() == null
|| !Names.WSA_NONE_ADDRESS.equals(
replyTo.getAddress().getValue())))) {
AttributedURIType address =
ContextUtils.getAttributedURI(isOneway
? Names.WSA_NONE_ADDRESS
: Names.WSA_ANONYMOUS_ADDRESS);
replyTo =
ContextUtils.WSA_OBJECT_FACTORY.createEndpointReferenceType();
replyTo.setAddress(address);
}
maps.setReplyTo(replyTo);
}
// FaultTo
if (maps.getFaultTo() == null) {
maps.setFaultTo(maps.getReplyTo());
} else if (maps.getFaultTo().getAddress() == null) {
maps.setFaultTo(null);
}
} else {
// add response-specific MAPs
AddressingPropertiesImpl inMAPs = getMAPs(message, false, false);
maps.exposeAs(inMAPs.getNamespaceURI());
// To taken from ReplyTo or FaultTo in incoming MAPs (depending
// on the fault status of the response)
if (isFault && inMAPs.getFaultTo() != null) {
maps.setTo(inMAPs.getFaultTo());
} else if (maps.getTo() == null && inMAPs.getReplyTo() != null) {
maps.setTo(inMAPs.getReplyTo());
}
// RelatesTo taken from MessageID in incoming MAPs
if (inMAPs.getMessageID() != null
&& !Boolean.TRUE.equals(message.get(Message.PARTIAL_RESPONSE_MESSAGE))) {
String inMessageID = inMAPs.getMessageID().getValue();
maps.setRelatesTo(ContextUtils.getRelatesTo(inMessageID));
}
// fallback fault action
if (isFault && maps.getAction() == null) {
maps.setAction(ContextUtils.getAttributedURI(
Names.WSA_DEFAULT_FAULT_ACTION));
}
if (isFault
&& !ContextUtils.isGenericAddress(inMAPs.getFaultTo())) {
ContextUtils.rebaseResponse(inMAPs.getFaultTo(),
inMAPs,
message);
}
}
}
/**
* Get the starting point MAPs (either empty or those set explicitly
* by the application on the binding provider request context).
*
* @param message the current message
* @param isProviderContext true if the binding provider request context
* available to the client application as opposed to the message context
* visible to handlers
* @param isOutbound true iff the message is outbound
* @return AddressingProperties retrieved MAPs
*/
private AddressingPropertiesImpl getMAPs(Message message,
boolean isProviderContext,
boolean isOutbound) {
AddressingPropertiesImpl maps = null;
maps = ContextUtils.retrieveMAPs(message,
isProviderContext,
isOutbound);
LOG.log(Level.INFO, "MAPs retrieved from message {0}", maps);
if (maps == null && isProviderContext) {
maps = new AddressingPropertiesImpl();
}
return maps;
}
/**
* Validate incoming MAPs
* @param maps the incoming MAPs
* @param message the current message
* @return true if incoming MAPs are valid
* @pre inbound message, not requestor
*/
private boolean validateIncomingMAPs(AddressingProperties maps,
Message message) {
boolean valid = true;
if (!allowDuplicates && maps != null) {
AttributedURIType messageID = maps.getMessageID();
if (messageID != null
&& messageIDs.put(messageID.getValue(),
messageID.getValue()) != null) {
LOG.log(Level.WARNING,
"DUPLICATE_MESSAGE_ID_MSG",
messageID.getValue());
String reason =
BUNDLE.getString("DUPLICATE_MESSAGE_ID_MSG");
String l7dReason =
MessageFormat.format(reason, messageID.getValue());
ContextUtils.storeMAPFaultName(Names.DUPLICATE_MESSAGE_ID_NAME,
message);
ContextUtils.storeMAPFaultReason(l7dReason, message);
valid = false;
}
}
return valid;
}
}
