addressingfaultshelper.java

来自「开源的axis2框架的源码。用于开发WEBSERVER」· Java 代码 · 共 412 行 · 第 1/2 页

                                   AddressingMessages.getMessage(
                                           "spec.final.FAULT_INVALID_HEADER_REASON"));
        }
    }

    //      wsa:OnlyAnonymousAddressSupported
    public static void triggerOnlyAnonymousAddressSupportedFault(MessageContext messageContext,
                                                                 String incorrectHeaderName)
            throws AxisFault {
        if (log.isDebugEnabled()) {
            log.debug("triggerOnlyAnonymousAddressSupportedFault: messageContext: " +
                    messageContext + " incorrectHeaderName: " + incorrectHeaderName);
        }
        String namespace =
                (String)messageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
        if (Submission.WSA_NAMESPACE.equals(namespace)) {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" +
                                           incorrectHeaderName, Submission.FAULT_INVALID_HEADER,
                                                                null, AddressingMessages.getMessage(
                    "spec.submission.FAULT_INVALID_HEADER_REASON"));
        } else {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" +
                                           incorrectHeaderName, Final.FAULT_INVALID_HEADER,
                                                                Final.FAULT_ONLY_ANONYMOUS_ADDRESS_SUPPORTED,
                                                                AddressingMessages.getMessage(
                                                                        "spec.final.FAULT_INVALID_HEADER_REASON"));
        }
    }

    //      wsa:OnlyNonAnonymousAddressSupported
    public static void triggerOnlyNonAnonymousAddressSupportedFault(MessageContext messageContext,
                                                                    String incorrectHeaderName)
            throws AxisFault {
        if (log.isDebugEnabled()) {
            log.debug("triggerOnlyNonAnonymousAddressSupportedFault: messageContext: " +
                    messageContext + " incorrectHeaderName: " + incorrectHeaderName);
        }
        String namespace =
                (String)messageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
        if (Submission.WSA_NAMESPACE.equals(namespace)) {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" +
                                           incorrectHeaderName, Submission.FAULT_INVALID_HEADER,
                                                                null, AddressingMessages.getMessage(
                    "spec.submission.FAULT_INVALID_HEADER_REASON"));
        } else {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" +
                                           incorrectHeaderName, Final.FAULT_INVALID_HEADER,
                                                                Final.FAULT_ONLY_NON_ANONYMOUS_ADDRESS_SUPPORTED,
                                                                AddressingMessages.getMessage(
                                                                        "spec.final.FAULT_INVALID_HEADER_REASON"));
        }
    }

    //    wsa:MessageAddressingHeaderRequired [Reason] the string: "A required header representing a Message Addressing Property is not present"
    public static void triggerMessageAddressingRequiredFault(MessageContext messageContext,
                                                             String missingHeaderName)
            throws AxisFault {
        if (log.isDebugEnabled()) {
            log.debug("triggerMessageAddressingRequiredFault: messageContext: " + messageContext +
                    " missingHeaderName: " + missingHeaderName);
        }
        String namespace =
                (String)messageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
        if (Submission.WSA_NAMESPACE.equals(namespace)) {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" + missingHeaderName,
                                   Submission.FAULT_ADDRESSING_HEADER_REQUIRED, null,
                                   AddressingMessages.getMessage(
                                           "spec.submission.FAULT_ADDRESSING_HEADER_REQUIRED_REASON"));
        } else {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_HEADER_QNAME,
                                   AddressingConstants.WSA_DEFAULT_PREFIX + ":" + missingHeaderName,
                                   Final.FAULT_ADDRESSING_HEADER_REQUIRED, null,
                                   AddressingMessages.getMessage(
                                           "spec.final.FAULT_ADDRESSING_HEADER_REQUIRED_REASON"));
        }
    }

    //    wsa:DestinationUnreachable [Reason] the string: "No route can be determined to reach [destination]"
    public static void triggerDestinationUnreachableFault(MessageContext messageContext,
                                                          String address) throws AxisFault {
        if (log.isDebugEnabled()) {
            log.debug("triggerDestinationUnreachableFault: messageContext: " + messageContext +
                    " address: " + address);
        }
        String namespace =
                (String)messageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
        if (Submission.WSA_NAMESPACE.equals(namespace)) {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_IRI, null,
                                   AddressingConstants.FAULT_ADDRESSING_DESTINATION_UNREACHABLE,
                                   null,
                                   AddressingMessages.getMessage(
                                           "spec.submission.FAULT_ADDRESSING_DESTINATION_UNREACHABLE_REASON"));
        } else {
            triggerAddressingFault(messageContext, Final.FAULT_HEADER_PROB_IRI, address,
                                   AddressingConstants.FAULT_ADDRESSING_DESTINATION_UNREACHABLE,
                                   null,
                                   AddressingMessages.getMessage(
                                           "spec.final.FAULT_ADDRESSING_DESTINATION_UNREACHABLE_REASON"));
        }
    }

    //    wsa:ActionNotSupported [Reason] the string: "The [action] cannot be processed at the receiver"
    public static void triggerActionNotSupportedFault(MessageContext messageContext,
                                                      String problemAction) throws AxisFault {
        if (log.isDebugEnabled()) {
            log.debug("triggerActionNotSupportedFault: messageContext: " + messageContext +
                    " problemAction: " + problemAction);
        }
        triggerAddressingFault(messageContext, Final.FAULT_PROBLEM_ACTION_NAME, problemAction,
                               AddressingConstants.FAULT_ACTION_NOT_SUPPORTED, null,
                               AddressingMessages.getMessage(
                                       "spec.FAULT_ACTION_NOT_SUPPORTED_REASON"));
    }

    //    wsa:EndpointUnavailable [Reason] the string "The endpoint is unable to process the message at this time"

    private static void triggerAddressingFault(MessageContext messageContext,
                                               String faultInformationKey,
                                               Object faultInformationValue, String faultcode,
                                               String faultSubcode, String faultReason)
            throws AxisFault {
        Map faultInformation =
                (Map)messageContext.getProperty(Constants.FAULT_INFORMATION_FOR_HEADERS);
        if (faultInformation == null) {
            faultInformation = new HashMap();
            messageContext.setProperty(Constants.FAULT_INFORMATION_FOR_HEADERS, faultInformation);
        }

        faultInformation.put(faultInformationKey, faultInformationValue);

        if (!messageContext.isSOAP11()) {
            setFaultCode(messageContext, faultcode, faultSubcode);
        }

        OperationContext oc = messageContext.getOperationContext();
        if (oc != null) {
            oc.setProperty(Constants.Configuration.SEND_STACKTRACE_DETAILS_WITH_FAULTS, "false");
        }

        messageContext.setProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES,
                                   Boolean.FALSE);
        String namespace =
                (String)messageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
        throw new AxisFault(faultReason, new QName(namespace, faultcode,
                                                   AddressingConstants.WSA_DEFAULT_PREFIX));
    }

    private static void setFaultCode(MessageContext messageContext, String faultCode,
                                     String faultSubCode) {
        SOAPFactory soapFac = OMAbstractFactory.getSOAP12Factory();
        SOAPFaultCode soapFaultCode = soapFac.createSOAPFaultCode();
        if (messageContext.isSOAP11()) {
            soapFaultCode.setText(faultCode);
        } else {
            SOAPFaultValue soapFaultValue = soapFac.createSOAPFaultValue(soapFaultCode);
            soapFaultValue.setText(SOAP12Constants.SOAP_DEFAULT_NAMESPACE_PREFIX + ":" +
                    SOAP12Constants.FAULT_CODE_SENDER);
            SOAPFaultSubCode soapFaultSubCode = soapFac.createSOAPFaultSubCode(soapFaultCode);
            SOAPFaultValue soapFaultSubcodeValue = soapFac.createSOAPFaultValue(soapFaultSubCode);
            soapFaultSubcodeValue.setText(AddressingConstants.WSA_DEFAULT_PREFIX + ":" + faultCode);
            if (faultSubCode != null) {
                SOAPFaultSubCode soapFaultSubCode2 =
                        soapFac.createSOAPFaultSubCode(soapFaultSubCode);
                SOAPFaultValue soapFaultSubcodeValue2 =
                        soapFac.createSOAPFaultValue(soapFaultSubCode2);
                soapFaultSubcodeValue2
                        .setText(AddressingConstants.WSA_DEFAULT_PREFIX + ":" + faultSubCode);
            }
        }
        messageContext.setProperty(SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME, soapFaultCode);
    }

    public static OMElement getDetailElementForAddressingFault(MessageContext messageContext,
                                                               OMNamespace addressingNamespaceObject) {
        Map faultInfo = (Map)messageContext.getProperty(Constants.FAULT_INFORMATION_FOR_HEADERS);
        OMElement problemDetail = null;
        if (faultInfo != null) {
            String faultyHeaderQName = (String)faultInfo.get(Final.FAULT_HEADER_PROB_HEADER_QNAME);
            String faultyAction = (String)faultInfo.get(Final.FAULT_PROBLEM_ACTION_NAME);
            String faultyAddress = (String)faultInfo.get(Final.FAULT_HEADER_PROB_IRI);
            if (faultyAddress != null && !"".equals(faultyAddress)) {
                problemDetail = messageContext.getEnvelope().getOMFactory().createOMElement(
                        Final.FAULT_HEADER_PROB_IRI, addressingNamespaceObject);
                problemDetail.setText(faultyAddress);
            }
            if (faultyAction != null && !"".equals(faultyAction)) {
                problemDetail = messageContext.getEnvelope().getOMFactory().createOMElement(
                        Final.FAULT_PROBLEM_ACTION_NAME, addressingNamespaceObject);
                OMElement probH2 = messageContext.getEnvelope().getOMFactory().createOMElement(
                        AddressingConstants.WSA_ACTION, addressingNamespaceObject, problemDetail);
                probH2.setText(faultyAction);
            }
            if (faultyHeaderQName != null && !"".equals(faultyHeaderQName)) {
                problemDetail = messageContext.getEnvelope().getOMFactory().createOMElement(
                        Final.FAULT_HEADER_PROB_HEADER_QNAME, addressingNamespaceObject);
                problemDetail.setText(faultyHeaderQName);
            }
        }
        return problemDetail;
    }
}