public void receive(org.apache.axis2.context.MessageContext mc) throws AxisFault { MessageContext synCtx = MessageContextCreatorForAxis2.getSynapseMessageContext(mc); StatisticsReporter.reportForComponent( synCtx, AspectConfigurationDetectionStrategy.getAspectConfiguration(synCtx), ComponentType.PROXYSERVICE); boolean traceOn = synCtx.getMainSequence().getTraceState() == SynapseConstants.TRACING_ON; boolean traceOrDebugOn = traceOn || log.isDebugEnabled(); if (traceOrDebugOn) { traceOrDebug(traceOn, "Synapse received a new message for message mediation..."); traceOrDebug( traceOn, "Received To: " + (mc.getTo() != null ? mc.getTo().getAddress() : "null")); traceOrDebug( traceOn, "SOAPAction: " + (mc.getSoapAction() != null ? mc.getSoapAction() : "null")); traceOrDebug( traceOn, "WSA-Action: " + (mc.getWSAAction() != null ? mc.getWSAAction() : "null")); if (traceOn && trace.isTraceEnabled()) { String[] cids = mc.getAttachmentMap().getAllContentIDs(); if (cids != null && cids.length > 0) { for (String cid : cids) { trace.trace("Attachment : " + cid); } } trace.trace("Envelope : " + mc.getEnvelope()); } } // get service log for this message and attach to the message context Log serviceLog = LogFactory.getLog( SynapseConstants.SERVICE_LOGGER_PREFIX + SynapseConstants.SYNAPSE_SERVICE_NAME); ((Axis2MessageContext) synCtx).setServiceLog(serviceLog); try { // invoke synapse message mediation through the main sequence synCtx.getEnvironment().injectMessage(synCtx); } catch (SynapseException syne) { if (!synCtx.getFaultStack().isEmpty()) { warn(traceOn, "Executing fault handler due to exception encountered", synCtx); ((FaultHandler) synCtx.getFaultStack().pop()).handleFault(synCtx, syne); } else { warn( traceOn, "Exception encountered but no fault handler found - " + "message dropped", synCtx); } } finally { StatisticsReporter.endReportForAllOnRequestProcessed(synCtx); } }
/** * Extract transport headers from the synapse message context. * * @param synCtx synapse message context * @return transport headers map */ public static Map<String, Object> extractTransportProperties(MessageContext synCtx) { Map<String, Object> transportPropertyMap = new TreeMap<>(); Axis2MessageContext axis2smc = (Axis2MessageContext) synCtx; org.apache.axis2.context.MessageContext axis2MessageCtx = axis2smc.getAxis2MessageContext(); Object headers = axis2MessageCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS); if (headers != null && headers instanceof Map) { Map headersMap = (Map) headers; Set<String> axis2PropertySet = headersMap.keySet(); for (String entry : axis2PropertySet) { transportPropertyMap.put(entry, headersMap.get(entry)); } } // Adding important transport related properties if (axis2MessageCtx.getTo() != null) { transportPropertyMap.put(SynapseConstants.HEADER_TO, axis2MessageCtx.getTo().getAddress()); } if (axis2MessageCtx.getFrom() != null) { transportPropertyMap.put( SynapseConstants.HEADER_FROM, axis2MessageCtx.getFrom().getAddress()); } if (axis2MessageCtx.getWSAAction() != null) { transportPropertyMap.put("WSAction", axis2MessageCtx.getWSAAction()); } if (axis2MessageCtx.getSoapAction() != null) { transportPropertyMap.put("SOAPAction", axis2MessageCtx.getSoapAction()); } if (axis2MessageCtx.getReplyTo() != null) { transportPropertyMap.put( SynapseConstants.HEADER_REPLY_TO, axis2MessageCtx.getReplyTo().getAddress()); } if (axis2MessageCtx.getMessageID() != null) { transportPropertyMap.put(SynapseConstants.HEADER_MESSAGE_ID, axis2MessageCtx.getMessageID()); } // Remove unnecessary properties if (transportPropertyMap.get("Cookie") != null) { transportPropertyMap.remove("Cookie"); } return transportPropertyMap; }
/** * Whether the original request received by the synapse is REST * * @param originalInMsgCtx request message * @return <code>true</code> if the request was a REST request */ private static boolean isRequestRest(MessageContext originalInMsgCtx) { boolean isRestRequest = originalInMsgCtx.getProperty(NhttpConstants.REST_REQUEST_CONTENT_TYPE) != null; if (!isRestRequest) { String httpMethod = (String) originalInMsgCtx.getProperty(Constants.Configuration.HTTP_METHOD); isRestRequest = Constants.Configuration.HTTP_METHOD_GET.equals(httpMethod) || Constants.Configuration.HTTP_METHOD_DELETE.equals(httpMethod) || Constants.Configuration.HTTP_METHOD_PUT.equals(httpMethod) || RESTConstants.METHOD_OPTIONS.equals(httpMethod) || Constants.Configuration.HTTP_METHOD_HEAD.equals(httpMethod); if (!isRestRequest) { isRestRequest = Constants.Configuration.HTTP_METHOD_POST.equals(httpMethod) && HTTPTransportUtils.isRESTRequest( String.valueOf( originalInMsgCtx.getProperty(Constants.Configuration.MESSAGE_TYPE))); if (!isRestRequest) { isRestRequest = (String.valueOf(originalInMsgCtx.getProperty(Constants.Configuration.MESSAGE_TYPE)) .equals(HTTPConstants.MEDIA_TYPE_TEXT_XML) && originalInMsgCtx.getSoapAction() == null); } } } return isRestRequest; }
private void sendUsingOutputStream(MessageContext msgContext) throws AxisFault { OMOutputFormat format = NhttpUtil.getOMOutputFormat(msgContext); MessageFormatter messageFormatter = MessageFormatterDecoratorFactory.createMessageFormatterDecorator(msgContext); OutputStream out = (OutputStream) msgContext.getProperty(MessageContext.TRANSPORT_OUT); if (msgContext.isServerSide()) { OutTransportInfo transportInfo = (OutTransportInfo) msgContext.getProperty(Constants.OUT_TRANSPORT_INFO); if (transportInfo != null) { transportInfo.setContentType( messageFormatter.getContentType(msgContext, format, msgContext.getSoapAction())); } else { throw new AxisFault(Constants.OUT_TRANSPORT_INFO + " has not been set"); } } try { messageFormatter.writeTo(msgContext, format, out, false); out.close(); } catch (IOException e) { handleException("IO Error sending response message", e); } }
/** * Invokes the bussiness logic invocation on the service implementation class * * @param msgContext the incoming message context * @param newmsgContext the response message context * @throws AxisFault on invalid method (wrong signature) or behaviour (return null) */ public void invokeBusinessLogic(MessageContext msgContext) throws AxisFault { Object obj = null; try { String in_action = msgContext.getWSAAction(); if (logger.isDebugEnabled()) { logger.debug("In MEP: in_action = " + in_action); } validate_action(msgContext); // get the implementation class for the Web Service obj = getTheImplementationObject(msgContext); // make return message context available to service if (obj instanceof AppendixV) { AppendixV xo = (AppendixV) obj; } } catch (Exception e) { logger.error( "Error in XDSRawXMLIn:\n" + ExceptionUtil.exception_details(e) + "\ngetSoapAction = " + msgContext.getSoapAction()); throw AxisFault.makeFault(e); } // find the WebService method Class implClass = obj.getClass(); AxisOperation opDesc = msgContext.getAxisOperation(); Method method = findOperation(opDesc, implClass); Method methodDisplay; try { methodDisplay = implClass.getMethod("setMessageContextIn", new Class[] {MessageContext.class}); } catch (SecurityException e) { logger.error( "Error in XDSRawXMLIn:\n" + "class is " + implClass.getName() + " method is setMessageContextIn" + ExceptionUtil.exception_details(e) + "\ngetSoapAction = " + msgContext.getSoapAction()); throw AxisFault.makeFault(e); } catch (NoSuchMethodException e) { logger.error( "Error in XDSRawXMLIn:\n" + "class is " + implClass.getName() + " method is setMessageContextIn" + ExceptionUtil.exception_details(e) + "\ngetSoapAction = " + msgContext.getSoapAction()); throw AxisFault.makeFault(e); } try { methodDisplay.invoke(obj, new Object[] {msgContext}); } catch (Exception e) { logger.error( "Error in XDSRawXMLIn:\n" + "class is " + implClass.getName() + " method is setMessageContextIn" + ExceptionUtil.exception_details(e) + "\ngetSoapAction = " + msgContext.getSoapAction()); throw AxisFault.makeFault(e); } if (method == null) { throw new AxisFault(Messages.getMessage("methodDoesNotExistIn", opDesc.getName().toString())); } try { method.invoke(obj, new Object[] {msgContext.getEnvelope().getBody().getFirstElement()}); } catch (Exception e) { logger.error( "Error in XDSRawXMLIn:\n" + "class is " + implClass.getName() + " method is setMessageContextIn" + ExceptionUtil.exception_details(e) + "\ngetSoapAction = " + msgContext.getSoapAction()); throw AxisFault.makeFault(e); } }
/** * Handle the response or error (during a failed send) message received for an outgoing request * * @param messageID Request message ID * @param response the Axis2 MessageContext that has been received and has to be handled * @param synapseOutMsgCtx the corresponding (outgoing) Synapse MessageContext for the above Axis2 * MC, that holds Synapse specific information such as the error handler stack and local * properties etc. * @throws AxisFault if the message cannot be processed */ private void handleMessage( String messageID, MessageContext response, org.apache.synapse.MessageContext synapseOutMsgCtx, AsyncCallback callback) throws AxisFault { // apply the tenant information to the out message context TenantInfoConfigurator configurator = synapseOutMsgCtx.getEnvironment().getTenantInfoConfigurator(); if (configurator != null) { configurator.applyTenantInfo(synapseOutMsgCtx); } Object o = response.getProperty(SynapseConstants.SENDING_FAULT); if (o != null && Boolean.TRUE.equals(o)) { StatisticsReporter.reportFaultForAll( synapseOutMsgCtx, ErrorLogFactory.createErrorLog(response)); // there is a sending fault. propagate the fault to fault handlers. Stack faultStack = synapseOutMsgCtx.getFaultStack(); if (faultStack != null && !faultStack.isEmpty()) { // if we have access to the full synapseOutMsgCtx.getEnvelope(), then let // it flow with the error details. Else, replace its envelope with the // fault envelope try { synapseOutMsgCtx.getEnvelope().build(); } catch (OMException x) { synapseOutMsgCtx.setEnvelope(response.getEnvelope()); } Exception e = (Exception) response.getProperty(SynapseConstants.ERROR_EXCEPTION); synapseOutMsgCtx.setProperty(SynapseConstants.SENDING_FAULT, Boolean.TRUE); synapseOutMsgCtx.setProperty( SynapseConstants.ERROR_CODE, response.getProperty(SynapseConstants.ERROR_CODE)); synapseOutMsgCtx.setProperty( SynapseConstants.ERROR_MESSAGE, response.getProperty(SynapseConstants.ERROR_MESSAGE)); synapseOutMsgCtx.setProperty( SynapseConstants.ERROR_DETAIL, response.getProperty(SynapseConstants.ERROR_DETAIL)); synapseOutMsgCtx.setProperty(SynapseConstants.ERROR_EXCEPTION, e); if (log.isDebugEnabled()) { log.debug( "[Failed Request Message ID : " + messageID + "]" + " [New to be Retried Request Message ID : " + synapseOutMsgCtx.getMessageID() + "]"); } int errorCode = (Integer) response.getProperty(SynapseConstants.ERROR_CODE); // If a timeout has occured and the timeout action of the callback is to discard the message if (errorCode == SynapseConstants.NHTTP_CONNECTION_TIMEOUT && callback.getTimeOutAction() == SynapseConstants.DISCARD) { // Do not execute any fault sequences. Discard message if (log.isWarnEnabled()) { log.warn( "Synapse timed out for the request with Message ID : " + messageID + ". Ignoring fault handlers since the timeout action is DISCARD"); } faultStack.removeAllElements(); } else { ((FaultHandler) faultStack.pop()).handleFault(synapseOutMsgCtx, null); } } } else { // there can always be only one instance of an Endpoint in the faultStack of a message // if the send was successful, so remove it before we proceed any further Stack faultStack = synapseOutMsgCtx.getFaultStack(); Endpoint successfulEndpoint = null; if (faultStack != null && !faultStack.isEmpty() && faultStack.peek() instanceof Endpoint) { successfulEndpoint = (Endpoint) faultStack.pop(); } if (log.isDebugEnabled()) { log.debug("Synapse received an asynchronous response message"); log.debug( "Received To: " + (response.getTo() != null ? response.getTo().getAddress() : "null")); log.debug( "SOAPAction: " + (response.getSoapAction() != null ? response.getSoapAction() : "null")); log.debug( "WSA-Action: " + (response.getWSAAction() != null ? response.getWSAAction() : "null")); String[] cids = response.getAttachmentMap().getAllContentIDs(); if (cids != null && cids.length > 0) { for (String cid : cids) { log.debug("Attachment : " + cid); } } log.debug("Body : \n" + response.getEnvelope()); } MessageContext axisOutMsgCtx = ((Axis2MessageContext) synapseOutMsgCtx).getAxis2MessageContext(); // Processes 'Accept-Encoding' ResponseAcceptEncodingProcessor.process(response, axisOutMsgCtx); response.setServiceContext(null); response.setOperationContext(axisOutMsgCtx.getOperationContext()); response.setAxisMessage( axisOutMsgCtx.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE)); // set properties on response response.setServerSide(true); response.setProperty(SynapseConstants.ISRESPONSE_PROPERTY, Boolean.TRUE); response.setProperty( MessageContext.TRANSPORT_OUT, axisOutMsgCtx.getProperty(MessageContext.TRANSPORT_OUT)); response.setProperty( org.apache.axis2.Constants.OUT_TRANSPORT_INFO, axisOutMsgCtx.getProperty(org.apache.axis2.Constants.OUT_TRANSPORT_INFO)); response.setTransportIn(axisOutMsgCtx.getTransportIn()); response.setTransportOut(axisOutMsgCtx.getTransportOut()); // If request is REST assume that the response is REST too response.setDoingREST(axisOutMsgCtx.isDoingREST()); if (axisOutMsgCtx.isDoingMTOM()) { response.setDoingMTOM(true); response.setProperty( org.apache.axis2.Constants.Configuration.ENABLE_MTOM, org.apache.axis2.Constants.VALUE_TRUE); } if (axisOutMsgCtx.isDoingSwA()) { response.setDoingSwA(true); response.setProperty( org.apache.axis2.Constants.Configuration.ENABLE_SWA, org.apache.axis2.Constants.VALUE_TRUE); } // when axis2 receives a soap message without addressing headers it users // DISABLE_ADDRESSING_FOR_OUT_MESSAGES property to keep it and hence avoid addressing // headers on the response. this causes a problem for synapse if the original message // it receivs (from client) has addressing and the synaspse service invocation has not // engage addressing. in this case when synapse receives the response from the server // addessing In handler dissable addressing since that response does not have addressing // headers. synapse sends the response to its orignal client using the same message // context. Then this response does not have addressing headers since it already // disable. to avoid this we need to set the DISABLE_ADDRESSING_FOR_OUT_MESSAGES // property state to original state. if (axisOutMsgCtx.getProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES) != null) { response.setProperty( AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, axisOutMsgCtx.getProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES)); } else { response.removeProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES); } Object messageType = axisOutMsgCtx.getProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE); if (!HTTPConstants.MEDIA_TYPE_X_WWW_FORM.equals(messageType)) { // copy the message type property that's used by the out message to the // response message response.setProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE, messageType); } // compare original received message (axisOutMsgCtx) soap version with the response // if they are different change to original version if (axisOutMsgCtx.isSOAP11() != response.isSOAP11()) { if (axisOutMsgCtx.isSOAP11()) { SOAPUtils.convertSOAP12toSOAP11(response); } else { SOAPUtils.convertSOAP11toSOAP12(response); } } if (axisOutMsgCtx.getMessageID() != null) { response.setRelationships(new RelatesTo[] {new RelatesTo(axisOutMsgCtx.getMessageID())}); } response.setReplyTo(axisOutMsgCtx.getReplyTo()); response.setFaultTo(axisOutMsgCtx.getFaultTo()); if (axisOutMsgCtx.isPropertyTrue(NhttpConstants.IGNORE_SC_ACCEPTED)) { response.setProperty(NhttpConstants.FORCE_SC_ACCEPTED, Constants.VALUE_TRUE); } // create the synapse message context for the response Axis2MessageContext synapseInMessageContext = new Axis2MessageContext( response, synapseOutMsgCtx.getConfiguration(), synapseOutMsgCtx.getEnvironment()); synapseInMessageContext.setResponse(true); Object obj = synapseOutMsgCtx.getProperty(SynapseConstants.FORCE_ERROR_PROPERTY); String errorOnSOAPFault = (String) obj; if (Constants.VALUE_TRUE.equals(errorOnSOAPFault) && successfulEndpoint != null) { if (log.isDebugEnabled()) { log.debug("FORCE_ERROR_ON_SOAP_FAULT is true, checking for SOAPFault"); } try { RelayUtils.buildMessage( ((Axis2MessageContext) synapseInMessageContext).getAxis2MessageContext(), true); } catch (Exception e) { // handleException("Error while building message", e, synapseInMessageContext); } if ((synapseInMessageContext.getEnvelope() != null) && synapseInMessageContext.getEnvelope().hasFault()) { if (log.isDebugEnabled()) { log.debug( "SOAPFault found in response message, forcing endpoint " + successfulEndpoint.getName() + " to fail"); } // setup new pipe configuration..if failure happens (this will be setup as the source // writer and during the TargetContext // clean up operation the writer will be reset and pull to the buffer MessageContext axis2OUTMC = ((Axis2MessageContext) synapseOutMsgCtx).getAxis2MessageContext(); NHttpServerConnection conn = (NHttpServerConnection) axis2OUTMC.getProperty("pass-through.Source-Connection"); if (conn != null) { SourceConfiguration sourceConfiguration = (SourceConfiguration) axis2OUTMC.getProperty("PASS_THROUGH_SOURCE_CONFIGURATION"); Pipe pipe = new Pipe( conn, sourceConfiguration.getBufferFactory().getBuffer(), "source", sourceConfiguration); axis2OUTMC.setProperty(PassThroughConstants.PASS_THROUGH_PIPE, pipe); } StatisticsReporter.reportFaultForAll( synapseOutMsgCtx, ErrorLogFactory.createErrorLog(response)); synapseOutMsgCtx.setProperty(SynapseConstants.SENDING_FAULT, Boolean.TRUE); synapseOutMsgCtx.setProperty( SynapseConstants.ERROR_CODE, SynapseConstants.ENDPOINT_CUSTOM_ERROR); ((FaultHandler) successfulEndpoint).handleFault(synapseOutMsgCtx, null); return; } else { successfulEndpoint.onSuccess(); } } else if (successfulEndpoint != null) { successfulEndpoint.onSuccess(); } synapseInMessageContext.setTo( new EndpointReference(AddressingConstants.Final.WSA_ANONYMOUS_URL)); synapseInMessageContext.setTracingState(synapseOutMsgCtx.getTracingState()); // set the properties of the original MC to the new MC for (Object key : synapseOutMsgCtx.getPropertyKeySet()) { synapseInMessageContext.setProperty( (String) key, synapseOutMsgCtx.getProperty((String) key)); } // Copy SequenceCallStack from original MC to the new MC if (synapseOutMsgCtx.isContinuationEnabled()) { // Set the message direction if (!synapseOutMsgCtx.isResponse()) { synapseInMessageContext.setResponse(false); } Stack<ContinuationState> seqContinuationStates = synapseOutMsgCtx.getContinuationStateStack(); for (int i = 0; i < seqContinuationStates.size(); i++) { synapseInMessageContext.pushContinuationState(seqContinuationStates.get(i)); } } // If this response is related to session affinity endpoints -Server initiated session Dispatcher dispatcher = (Dispatcher) synapseOutMsgCtx.getProperty(SynapseConstants.PROP_SAL_ENDPOINT_CURRENT_DISPATCHER); if (dispatcher != null && dispatcher.isServerInitiatedSession()) { dispatcher.updateSession(synapseInMessageContext); } StatisticsReporter.reportForAllOnResponseReceived(synapseInMessageContext); // send the response message through the synapse mediation flow try { synapseOutMsgCtx.getEnvironment().injectMessage(synapseInMessageContext); } catch (SynapseException syne) { Stack stack = synapseInMessageContext.getFaultStack(); if (stack != null && !stack.isEmpty()) { ((FaultHandler) stack.pop()).handleFault(synapseInMessageContext, syne); } else { log.error( "Synapse encountered an exception, " + "No error handlers found - [Message Dropped]\n" + syne.getMessage()); } } } }
public void receive(org.apache.axis2.context.MessageContext mc) throws AxisFault { boolean traceOn = proxy.getAspectConfiguration().isTracingEnabled(); boolean traceOrDebugOn = traceOn || log.isDebugEnabled(); CustomLogSetter.getInstance().setLogAppender(proxy.getArtifactContainerName()); String remoteAddr = (String) mc.getProperty(org.apache.axis2.context.MessageContext.REMOTE_ADDR); if (traceOrDebugOn) { traceOrDebug( traceOn, "Proxy Service " + name + " received a new message" + (remoteAddr != null ? " from : " + remoteAddr : "...")); traceOrDebug( traceOn, ("Message To: " + (mc.getTo() != null ? mc.getTo().getAddress() : "null"))); traceOrDebug( traceOn, ("SOAPAction: " + (mc.getSoapAction() != null ? mc.getSoapAction() : "null"))); traceOrDebug( traceOn, ("WSA-Action: " + (mc.getWSAAction() != null ? mc.getWSAAction() : "null"))); if (traceOn && trace.isTraceEnabled()) { String[] cids = mc.getAttachmentMap().getAllContentIDs(); if (cids != null && cids.length > 0) { for (String cid : cids) { trace.trace("With attachment content ID : " + cid); } } trace.trace("Envelope : " + mc.getEnvelope()); } } MessageContext synCtx = MessageContextCreatorForAxis2.getSynapseMessageContext(mc); Integer statisticReportingIndex = null; // Statistic reporting boolean isStatisticsEnabled = RuntimeStatisticCollector.isStatisticsEnabled(); if (isStatisticsEnabled) { statisticReportingIndex = OpenEventCollector.reportEntryEvent( synCtx, this.name, proxy.getAspectConfiguration(), ComponentType.PROXYSERVICE); } Object inboundServiceParam = proxy.getParameterMap().get(SynapseConstants.INBOUND_PROXY_SERVICE_PARAM); Object inboundMsgCtxParam = mc.getProperty(SynapseConstants.IS_INBOUND); // check whether the message is from Inbound EP if (inboundMsgCtxParam == null || !(boolean) inboundMsgCtxParam) { // check whether service parameter is set to true or null, then block this request if (inboundServiceParam != null && (Boolean.valueOf((String) inboundServiceParam))) { /* return because same proxy is exposed via InboundEP and service parameter(inbound.only) is set to true, which disable normal http transport proxy */ if (!synCtx.getFaultStack().isEmpty()) { if (log.isDebugEnabled()) { log.debug( "Executing fault handler - message discarded due to the proxy is allowed only via InboundEP"); } (synCtx.getFaultStack().pop()) .handleFault( synCtx, new Exception( "Proxy Service " + name + " message discarded due to the proxy is allowed only via InboundEP")); } else { if (log.isDebugEnabled()) { log.debug( "Proxy Service " + name + " message discarded due to the proxy is " + "allowed only via InboundEP"); } } return; } } TenantInfoConfigurator configurator = synCtx.getEnvironment().getTenantInfoConfigurator(); if (configurator != null) { configurator.extractTenantInfo(synCtx); } TransportInDescription trpInDesc = mc.getTransportIn(); if (trpInDesc != null) { synCtx.setProperty(SynapseConstants.TRANSPORT_IN_NAME, trpInDesc.getName()); } // get service log for this message and attach to the message context also set proxy name Log serviceLog = LogFactory.getLog(SynapseConstants.SERVICE_LOGGER_PREFIX + name); ((Axis2MessageContext) synCtx).setServiceLog(serviceLog); synCtx.setProperty(SynapseConstants.PROXY_SERVICE, name); // synCtx.setTracingState(proxy.getTraceState()); synCtx.setProperty(SynapseConstants.IS_CLIENT_DOING_REST, mc.isDoingREST()); synCtx.setProperty(SynapseConstants.IS_CLIENT_DOING_SOAP11, mc.isSOAP11()); try { if (synCtx.getEnvironment().isDebuggerEnabled()) { SynapseDebugManager debugManager = synCtx.getEnvironment().getSynapseDebugManager(); debugManager.acquireMediationFlowLock(); debugManager.advertiseMediationFlowStartPoint(synCtx); if (!synCtx.isResponse()) { SynapseWireLogHolder wireLogHolder = (SynapseWireLogHolder) ((Axis2MessageContext) synCtx) .getAxis2MessageContext() .getProperty(SynapseDebugInfoHolder.SYNAPSE_WIRE_LOG_HOLDER_PROPERTY); if (wireLogHolder == null) { wireLogHolder = new SynapseWireLogHolder(); } if (synCtx.getProperty(SynapseConstants.PROXY_SERVICE) != null && !synCtx.getProperty(SynapseConstants.PROXY_SERVICE).toString().isEmpty()) { wireLogHolder.setProxyName( synCtx.getProperty(SynapseConstants.PROXY_SERVICE).toString()); } ((Axis2MessageContext) synCtx) .getAxis2MessageContext() .setProperty(SynapseDebugInfoHolder.SYNAPSE_WIRE_LOG_HOLDER_PROPERTY, wireLogHolder); } } synCtx.setProperty(SynapseConstants.RESPONSE_STATE, new ResponseState()); List handlers = synCtx.getEnvironment().getSynapseHandlers(); Iterator<SynapseHandler> iterator = handlers.iterator(); while (iterator.hasNext()) { SynapseHandler handler = iterator.next(); if (!handler.handleRequestInFlow(synCtx)) { return; } } Mediator mandatorySeq = synCtx.getConfiguration().getMandatorySequence(); if (mandatorySeq != null) { if (log.isDebugEnabled()) { log.debug( "Start mediating the message in the " + "pre-mediate state using the mandatory sequence"); } if (!mandatorySeq.mediate(synCtx)) { if (log.isDebugEnabled()) { log.debug( "Request message for the proxy service " + name + " dropped in " + "the pre-mediation state by the mandatory sequence : \n" + synCtx); } return; } } // setup fault sequence - i.e. what happens when something goes wrong with this message proxy.registerFaultHandler(synCtx); boolean inSequenceResult = true; // Using inSequence for the incoming message mediation if (proxy.getTargetInSequence() != null) { Mediator inSequence = synCtx.getSequence(proxy.getTargetInSequence()); if (inSequence != null) { traceOrDebug( traceOn, "Using sequence named : " + proxy.getTargetInSequence() + " for incoming message mediation"); inSequenceResult = inSequence.mediate(synCtx); } else { handleException("Unable to find in-sequence : " + proxy.getTargetInSequence(), synCtx); } } else if (proxy.getTargetInLineInSequence() != null) { traceOrDebug( traceOn, "Using the anonymous " + "in-sequence of the proxy service for mediation"); inSequenceResult = proxy.getTargetInLineInSequence().mediate(synCtx); } // if inSequence returns true, forward message to endpoint if (inSequenceResult) { if (proxy.getTargetEndpoint() != null) { Endpoint endpoint = synCtx.getEndpoint(proxy.getTargetEndpoint()); if (endpoint != null) { traceOrDebug( traceOn, "Forwarding message to the endpoint : " + proxy.getTargetEndpoint()); endpoint.send(synCtx); } else { handleException( "Unable to find the endpoint specified : " + proxy.getTargetEndpoint(), synCtx); } } else if (proxy.getTargetInLineEndpoint() != null) { traceOrDebug( traceOn, "Forwarding the message to the anonymous " + "endpoint of the proxy service"); proxy.getTargetInLineEndpoint().send(synCtx); } } } catch (SynapseException syne) { if (!synCtx.getFaultStack().isEmpty()) { warn(traceOn, "Executing fault handler due to exception encountered", synCtx); ((FaultHandler) synCtx.getFaultStack().pop()).handleFault(synCtx, syne); } else { warn( traceOn, "Exception encountered but no fault handler found - " + "message dropped", synCtx); } } finally { // Statistic reporting if (isStatisticsEnabled) { CloseEventCollector.tryEndFlow( synCtx, this.name, ComponentType.PROXYSERVICE, statisticReportingIndex, true); } if (synCtx.getEnvironment().isDebuggerEnabled()) { SynapseDebugManager debugManager = synCtx.getEnvironment().getSynapseDebugManager(); debugManager.advertiseMediationFlowTerminatePoint(synCtx); debugManager.releaseMediationFlowLock(); } } }
/** * Based on the Axis2 client code. Sends the Axis2 Message context out and returns the Axis2 * message context for the response. * * <p>Here Synapse works as a Client to the service. It would expect 200 ok, 202 ok and 500 * internal server error as possible responses. * * @param endpoint the endpoint being sent to, maybe null * @param synapseOutMessageContext the outgoing synapse message * @throws AxisFault on errors */ public static void send( EndpointDefinition endpoint, org.apache.synapse.MessageContext synapseOutMessageContext) throws AxisFault { boolean separateListener = false; boolean wsSecurityEnabled = false; String wsSecPolicyKey = null; String inboundWsSecPolicyKey = null; String outboundWsSecPolicyKey = null; boolean wsRMEnabled = false; String wsRMPolicyKey = null; boolean wsAddressingEnabled = false; String wsAddressingVersion = null; if (endpoint != null) { separateListener = endpoint.isUseSeparateListener(); wsSecurityEnabled = endpoint.isSecurityOn(); wsSecPolicyKey = endpoint.getWsSecPolicyKey(); inboundWsSecPolicyKey = endpoint.getInboundWsSecPolicyKey(); outboundWsSecPolicyKey = endpoint.getOutboundWsSecPolicyKey(); wsRMEnabled = endpoint.isReliableMessagingOn(); wsRMPolicyKey = endpoint.getWsRMPolicyKey(); wsAddressingEnabled = endpoint.isAddressingOn() || wsRMEnabled; wsAddressingVersion = endpoint.getAddressingVersion(); } if (log.isDebugEnabled()) { String to; if (endpoint != null && endpoint.getAddress() != null) { to = endpoint.getAddress(synapseOutMessageContext); } else { to = synapseOutMessageContext.getTo().toString(); } log.debug( "Sending [add = " + wsAddressingEnabled + "] [sec = " + wsSecurityEnabled + "] [rm = " + wsRMEnabled + (endpoint != null ? "] [mtom = " + endpoint.isUseMTOM() + "] [swa = " + endpoint.isUseSwa() + "] [format = " + endpoint.getFormat() + "] [force soap11=" + endpoint.isForceSOAP11() + "] [force soap12=" + endpoint.isForceSOAP12() + "] [pox=" + endpoint.isForcePOX() + "] [get=" + endpoint.isForceGET() + "] [encoding=" + endpoint.getCharSetEncoding() : "") + "] [to=" + to + "]"); } // save the original message context without altering it, so we can tie the response MessageContext originalInMsgCtx = ((Axis2MessageContext) synapseOutMessageContext).getAxis2MessageContext(); // TODO Temp hack: ESB removes the session id from request in a random manner. Map headers = (Map) originalInMsgCtx.getProperty(MessageContext.TRANSPORT_HEADERS); String session = (String) synapseOutMessageContext.getProperty("LB_COOKIE_HEADER"); if (session != null) { headers.put("Cookie", session); } // create a new MessageContext to be sent out as this should not corrupt the original // we need to create the response to the original message later on String preserveAddressingProperty = (String) synapseOutMessageContext.getProperty(SynapseConstants.PRESERVE_WS_ADDRESSING); MessageContext axisOutMsgCtx = cloneForSend(originalInMsgCtx, preserveAddressingProperty); if (log.isDebugEnabled()) { log.debug( "Message [Original Request Message ID : " + synapseOutMessageContext.getMessageID() + "]" + " [New Cloned Request Message ID : " + axisOutMsgCtx.getMessageID() + "]"); } // set all the details of the endpoint only to the cloned message context // so that we can use the original message context for resending through different endpoints if (endpoint != null) { if (SynapseConstants.FORMAT_POX.equals(endpoint.getFormat())) { axisOutMsgCtx.setDoingREST(true); axisOutMsgCtx.setProperty( org.apache.axis2.Constants.Configuration.MESSAGE_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML); axisOutMsgCtx.setProperty( Constants.Configuration.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML); Object o = axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS); Map _headers = (Map) o; if (_headers != null) { _headers.remove(HTTP.CONTENT_TYPE); _headers.put( HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML); } } else if (SynapseConstants.FORMAT_GET.equals(endpoint.getFormat())) { axisOutMsgCtx.setDoingREST(true); axisOutMsgCtx.setProperty( Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_GET); axisOutMsgCtx.setProperty( org.apache.axis2.Constants.Configuration.MESSAGE_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_X_WWW_FORM); } else if (SynapseConstants.FORMAT_SOAP11.equals(endpoint.getFormat())) { axisOutMsgCtx.setDoingREST(false); axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE); // We need to set this explicitly here in case the request was not a POST axisOutMsgCtx.setProperty( Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_POST); if (axisOutMsgCtx.getSoapAction() == null && axisOutMsgCtx.getWSAAction() != null) { axisOutMsgCtx.setSoapAction(axisOutMsgCtx.getWSAAction()); } if (!axisOutMsgCtx.isSOAP11()) { SOAPUtils.convertSOAP12toSOAP11(axisOutMsgCtx); } Object o = axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS); Map _headers = (Map) o; if (_headers != null) { _headers.remove(HTTP.CONTENT_TYPE); _headers.put( HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_TEXT_XML); } } else if (SynapseConstants.FORMAT_SOAP12.equals(endpoint.getFormat())) { axisOutMsgCtx.setDoingREST(false); axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE); // We need to set this explicitly here in case the request was not a POST axisOutMsgCtx.setProperty( Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_POST); if (axisOutMsgCtx.getSoapAction() == null && axisOutMsgCtx.getWSAAction() != null) { axisOutMsgCtx.setSoapAction(axisOutMsgCtx.getWSAAction()); } if (axisOutMsgCtx.isSOAP11()) { SOAPUtils.convertSOAP11toSOAP12(axisOutMsgCtx); } Object o = axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS); Map _headers = (Map) o; if (_headers != null) { _headers.remove(HTTP.CONTENT_TYPE); _headers.put( HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML); } } else if (SynapseConstants.FORMAT_REST.equals(endpoint.getFormat())) { /*format=rest is kept only backword compatibility. We no longer needed that.*/ /* Remove Message Type for GET and DELETE Request */ if (originalInMsgCtx.getProperty(Constants.Configuration.HTTP_METHOD) != null) { if (originalInMsgCtx .getProperty(Constants.Configuration.HTTP_METHOD) .toString() .equals(Constants.Configuration.HTTP_METHOD_GET) || originalInMsgCtx .getProperty(Constants.Configuration.HTTP_METHOD) .toString() .equals(Constants.Configuration.HTTP_METHOD_DELETE)) { axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE); } } axisOutMsgCtx.setDoingREST(true); } else { processWSDL2RESTRequestMessageType(originalInMsgCtx, axisOutMsgCtx); } if (endpoint.isUseMTOM()) { axisOutMsgCtx.setDoingMTOM(true); // fix / workaround for AXIS2-1798 axisOutMsgCtx.setProperty( org.apache.axis2.Constants.Configuration.ENABLE_MTOM, org.apache.axis2.Constants.VALUE_TRUE); axisOutMsgCtx.setDoingMTOM(true); } else if (endpoint.isUseSwa()) { axisOutMsgCtx.setDoingSwA(true); // fix / workaround for AXIS2-1798 axisOutMsgCtx.setProperty( org.apache.axis2.Constants.Configuration.ENABLE_SWA, org.apache.axis2.Constants.VALUE_TRUE); axisOutMsgCtx.setDoingSwA(true); } if (endpoint.getCharSetEncoding() != null) { axisOutMsgCtx.setProperty( Constants.Configuration.CHARACTER_SET_ENCODING, endpoint.getCharSetEncoding()); // Need to Clean this up. TargetRequest line 176 contains a code block which over writes the // Content-Type returned by the message formatter with the Content-Type in // TRANSPORT_HEADERS. Because of that, even when // the Character set encoding is set by the message formatter, it will be replaced by the // Content-Type header in TRANSPORT_HEADERS. // So Im setting a property to check in TargetRequest before over writing the header. axisOutMsgCtx.setProperty("EndpointCharEncodingSet", "true"); } // HTTP Endpoint : use the specified HTTP method and remove REST_URL_POSTFIX, it's not // supported in HTTP Endpoint if (endpoint.isHTTPEndpoint()) { axisOutMsgCtx.setProperty( Constants.Configuration.HTTP_METHOD, synapseOutMessageContext.getProperty(Constants.Configuration.HTTP_METHOD)); axisOutMsgCtx.removeProperty(NhttpConstants.REST_URL_POSTFIX); } // add rest request' suffix URI String restSuffix = (String) axisOutMsgCtx.getProperty(NhttpConstants.REST_URL_POSTFIX); boolean isRest = SynapseConstants.FORMAT_REST.equals(endpoint.getFormat()); if (!isRest && !endpoint.isForceSOAP11() && !endpoint.isForceSOAP12()) { isRest = isRequestRest(originalInMsgCtx); } if (endpoint.getAddress() != null) { String address = endpoint.getAddress(synapseOutMessageContext); if (isRest && restSuffix != null && !"".equals(restSuffix)) { String url; if (!address.endsWith("/") && !restSuffix.startsWith("/") && !restSuffix.startsWith("?")) { url = address + "/" + restSuffix; } else if (address.endsWith("/") && restSuffix.startsWith("/")) { url = address + restSuffix.substring(1); } else if (address.endsWith("/") && restSuffix.startsWith("?")) { url = address.substring(0, address.length() - 1) + restSuffix; } else { url = address + restSuffix; } axisOutMsgCtx.setTo(new EndpointReference(url)); } else { axisOutMsgCtx.setTo(new EndpointReference(address)); } axisOutMsgCtx.setProperty(NhttpConstants.ENDPOINT_PREFIX, address); synapseOutMessageContext.setProperty(SynapseConstants.ENDPOINT_PREFIX, address); } else { // Supporting RESTful invocation if (isRest && restSuffix != null && !"".equals(restSuffix)) { EndpointReference epr = axisOutMsgCtx.getTo(); if (epr != null) { String address = epr.getAddress(); String url; if (!address.endsWith("/") && !restSuffix.startsWith("/") && !restSuffix.startsWith("?")) { url = address + "/" + restSuffix; } else { url = address + restSuffix; } axisOutMsgCtx.setTo(new EndpointReference(url)); } } } if (endpoint.isUseSeparateListener()) { axisOutMsgCtx.getOptions().setUseSeparateListener(true); } } else { processWSDL2RESTRequestMessageType(originalInMsgCtx, axisOutMsgCtx); } // only put whttp:location for the REST (GET) requests, otherwise causes issues for POX messages if (axisOutMsgCtx.isDoingREST() && HTTPConstants.MEDIA_TYPE_X_WWW_FORM.equals( axisOutMsgCtx.getProperty(Constants.Configuration.MESSAGE_TYPE))) { if (axisOutMsgCtx.getProperty(WSDL2Constants.ATTR_WHTTP_LOCATION) == null && axisOutMsgCtx.getEnvelope().getBody().getFirstElement() != null) { axisOutMsgCtx.setProperty( WSDL2Constants.ATTR_WHTTP_LOCATION, axisOutMsgCtx.getEnvelope().getBody().getFirstElement().getQName().getLocalPart()); } } if (wsAddressingEnabled) { if (wsAddressingVersion != null && SynapseConstants.ADDRESSING_VERSION_SUBMISSION.equals(wsAddressingVersion)) { axisOutMsgCtx.setProperty( AddressingConstants.WS_ADDRESSING_VERSION, AddressingConstants.Submission.WSA_NAMESPACE); } else if (wsAddressingVersion != null && SynapseConstants.ADDRESSING_VERSION_FINAL.equals(wsAddressingVersion)) { axisOutMsgCtx.setProperty( AddressingConstants.WS_ADDRESSING_VERSION, AddressingConstants.Final.WSA_NAMESPACE); } axisOutMsgCtx.setProperty( AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.FALSE); } else { axisOutMsgCtx.setProperty( AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.TRUE); } // remove the headers if we don't need to preserve them. // determine weather we need to preserve the processed headers String preserveHeaderProperty = (String) synapseOutMessageContext.getProperty(SynapseConstants.PRESERVE_PROCESSED_HEADERS); if (preserveHeaderProperty == null || !Boolean.parseBoolean(preserveHeaderProperty)) { // default behaviour is to remove the headers MessageHelper.removeProcessedHeaders( axisOutMsgCtx, (preserveAddressingProperty != null && Boolean.parseBoolean(preserveAddressingProperty))); } ConfigurationContext axisCfgCtx = axisOutMsgCtx.getConfigurationContext(); AxisConfiguration axisCfg = axisCfgCtx.getAxisConfiguration(); AxisService anoymousService = AnonymousServiceFactory.getAnonymousService( synapseOutMessageContext.getConfiguration(), axisCfg, wsAddressingEnabled, wsRMEnabled, wsSecurityEnabled); // mark the anon services created to be used in the client side of synapse as hidden // from the server side of synapse point of view anoymousService.getParent().addParameter(SynapseConstants.HIDDEN_SERVICE_PARAM, "true"); ServiceGroupContext sgc = new ServiceGroupContext(axisCfgCtx, (AxisServiceGroup) anoymousService.getParent()); ServiceContext serviceCtx = sgc.getServiceContext(anoymousService); boolean outOnlyMessage = "true".equals(synapseOutMessageContext.getProperty(SynapseConstants.OUT_ONLY)); // get a reference to the DYNAMIC operation of the Anonymous Axis2 service AxisOperation axisAnonymousOperation = anoymousService.getOperation( outOnlyMessage ? new QName(AnonymousServiceFactory.OUT_ONLY_OPERATION) : new QName(AnonymousServiceFactory.OUT_IN_OPERATION)); Options clientOptions = MessageHelper.cloneOptions(originalInMsgCtx.getOptions()); clientOptions.setUseSeparateListener(separateListener); // if RM is requested, if (wsRMEnabled) { // if a WS-RM policy is specified, use it if (wsRMPolicyKey != null) { Object property = synapseOutMessageContext.getEntry(wsRMPolicyKey); if (property instanceof OMElement) { OMElement policyOMElement = (OMElement) property; RMAssertionBuilder builder = new RMAssertionBuilder(); SandeshaPolicyBean sandeshaPolicyBean = (SandeshaPolicyBean) builder.build(policyOMElement, null); Parameter policyParam = new Parameter(Sandesha2Constants.SANDESHA_PROPERTY_BEAN, sandeshaPolicyBean); anoymousService.addParameter(policyParam); } } } // if security is enabled, if (wsSecurityEnabled) { // if a WS-Sec policy is specified, use it if (wsSecPolicyKey != null) { clientOptions.setProperty( SynapseConstants.RAMPART_POLICY, MessageHelper.getPolicy(synapseOutMessageContext, wsSecPolicyKey)); } else { if (inboundWsSecPolicyKey != null) { clientOptions.setProperty( SynapseConstants.RAMPART_IN_POLICY, MessageHelper.getPolicy(synapseOutMessageContext, inboundWsSecPolicyKey)); } if (outboundWsSecPolicyKey != null) { clientOptions.setProperty( SynapseConstants.RAMPART_OUT_POLICY, MessageHelper.getPolicy(synapseOutMessageContext, outboundWsSecPolicyKey)); } } // temporary workaround for https://issues.apache.org/jira/browse/WSCOMMONS-197 if (axisOutMsgCtx.getEnvelope().getHeader() == null) { SOAPFactory fac = axisOutMsgCtx.isSOAP11() ? OMAbstractFactory.getSOAP11Factory() : OMAbstractFactory.getSOAP12Factory(); fac.createSOAPHeader(axisOutMsgCtx.getEnvelope()); } } OperationClient mepClient = axisAnonymousOperation.createClient(serviceCtx, clientOptions); mepClient.addMessageContext(axisOutMsgCtx); axisOutMsgCtx.setAxisMessage( axisAnonymousOperation.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE)); // set the SEND_TIMEOUT for transport sender if (endpoint != null && endpoint.getTimeoutDuration() > 0) { axisOutMsgCtx.setProperty(SynapseConstants.SEND_TIMEOUT, endpoint.getTimeoutDuration()); } // always set a callback as we decide if the send it blocking or non blocking within // the MEP client. This does not cause an overhead, as we simply create a 'holder' // object with a reference to the outgoing synapse message context // synapseOutMessageContext AsyncCallback callback = new AsyncCallback(axisOutMsgCtx, synapseOutMessageContext); if (!outOnlyMessage) { if (endpoint != null) { // set the timeout time and the timeout action to the callback, so that the // TimeoutHandler can detect timed out callbacks and take approprite action. callback.setTimeOutOn(System.currentTimeMillis() + endpoint.getTimeoutDuration()); callback.setTimeOutAction(endpoint.getTimeoutAction()); } else { callback.setTimeOutOn(System.currentTimeMillis()); } } mepClient.setCallback(callback); // // if (Utils.isClientThreadNonBlockingPropertySet(axisOutMsgCtx)) { // SynapseCallbackReceiver synapseCallbackReceiver = (SynapseCallbackReceiver) // axisOutMsgCtx.getAxisOperation().getMessageReceiver(); // synapseCallbackReceiver.addCallback(axisOutMsgCtx.getMessageID(), new // FaultCallback(axisOutMsgCtx, synapseOutMessageContext)); // } // this is a temporary fix for converting messages from HTTP 1.1 chunking to HTTP 1.0. // Without this HTTP transport can block & become unresponsive because we are streaming // HTTP 1.1 messages and HTTP 1.0 require the whole message to caculate the content length if (originalInMsgCtx.isPropertyTrue(NhttpConstants.FORCE_HTTP_1_0)) { synapseOutMessageContext.getEnvelope().toString(); } // with the nio transport, this causes the listener not to write a 202 // Accepted response, as this implies that Synapse does not yet know if // a 202 or 200 response would be written back. originalInMsgCtx .getOperationContext() .setProperty(org.apache.axis2.Constants.RESPONSE_WRITTEN, "SKIP"); // if the transport out is explicitly set use it Object o = originalInMsgCtx.getProperty("TRANSPORT_OUT_DESCRIPTION"); if (o != null && o instanceof TransportOutDescription) { axisOutMsgCtx.setTransportOut((TransportOutDescription) o); clientOptions.setTransportOut((TransportOutDescription) o); clientOptions.setProperty("TRANSPORT_OUT_DESCRIPTION", o); } mepClient.execute(true); if (wsRMEnabled) { Object rm11 = clientOptions.getProperty(SandeshaClientConstants.RM_SPEC_VERSION); if ((rm11 != null) && rm11.equals(Sandesha2Constants.SPEC_VERSIONS.v1_1)) { ServiceClient serviceClient = new ServiceClient( axisOutMsgCtx.getConfigurationContext(), axisOutMsgCtx.getAxisService()); serviceClient.setTargetEPR( new EndpointReference(endpoint.getAddress(synapseOutMessageContext))); serviceClient.setOptions(clientOptions); serviceClient .getOptions() .setTo(new EndpointReference(endpoint.getAddress(synapseOutMessageContext))); SandeshaClient.terminateSequence(serviceClient); } } }
/** * Send the passed in response message, asynchronously * * @param msgContext the message context to be sent * @throws AxisFault on error */ private void sendAsyncResponse(MessageContext msgContext) throws AxisFault { int contentLength = extractContentLength(msgContext); // remove unwanted HTTP headers (if any from the current message) removeUnwantedHeaders(msgContext); Map transportHeaders = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS); ServerWorker worker = (ServerWorker) msgContext.getProperty(Constants.OUT_TRANSPORT_INFO); HttpResponse response = worker.getResponse(); OMOutputFormat format = NhttpUtil.getOMOutputFormat(msgContext); MessageFormatter messageFormatter = MessageFormatterDecoratorFactory.createMessageFormatterDecorator(msgContext); Boolean noEntityBody = (Boolean) msgContext.getProperty(NhttpConstants.NO_ENTITY_BODY); if (noEntityBody == null || Boolean.FALSE == noEntityBody) { response.setHeader( HTTP.CONTENT_TYPE, messageFormatter.getContentType(msgContext, format, msgContext.getSoapAction())); } else if (Boolean.TRUE == noEntityBody) { ((BasicHttpEntity) response.getEntity()).setChunked(false); ((BasicHttpEntity) response.getEntity()).setContentLength(0); // Since HTTP HEAD request doesn't contain message body content length of the is set to be 0. // To handle // content length 0 while serving head method, content length of the backend response is set // as the content // as synapse cannot calculate content length without providing message body. if (transportHeaders.get(NhttpConstants.HTTP_REQUEST_METHOD) != null && NhttpConstants.HTTP_HEAD.equals( transportHeaders.get(NhttpConstants.HTTP_REQUEST_METHOD)) && transportHeaders.get(NhttpConstants.ORIGINAL_CONTENT_LEN) != null) { ((BasicHttpEntity) response.getEntity()) .setContentLength( Long.parseLong( String.valueOf(transportHeaders.get(NhttpConstants.ORIGINAL_CONTENT_LEN)))); transportHeaders.remove(NhttpConstants.ORIGINAL_CONTENT_LEN); transportHeaders.remove(NhttpConstants.HTTP_REQUEST_METHOD); } } response.setStatusCode(determineHttpStatusCode(msgContext, response)); // Override the Standard Reason Phrase if (msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE) != null && !msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE).equals("")) { response.setReasonPhrase( msgContext.getProperty(NhttpConstants.HTTP_REASON_PHRASE).toString()); } // set any transport headers if (transportHeaders != null && !transportHeaders.values().isEmpty()) { Iterator iter = transportHeaders.keySet().iterator(); while (iter.hasNext()) { Object header = iter.next(); Object value = transportHeaders.get(header); if (value != null && header instanceof String && value instanceof String) { response.addHeader((String) header, (String) value); String excessProp = NhttpConstants.EXCESS_TRANSPORT_HEADERS; Map map = (Map) msgContext.getProperty(excessProp); if (map != null && map.get(header) != null) { log.debug( "Number of excess values for " + header + " header is : " + ((Collection) (map.get(header))).size()); for (Iterator iterator = map.keySet().iterator(); iterator.hasNext(); ) { String key = (String) iterator.next(); for (String excessVal : (Collection<String>) map.get(key)) { if (header.equals(key)) { response.addHeader((String) header, (String) excessVal); } } } } } } } boolean forceContentLength = msgContext.isPropertyTrue(NhttpConstants.FORCE_HTTP_CONTENT_LENGTH); boolean forceContentLengthCopy = msgContext.isPropertyTrue(NhttpConstants.COPY_CONTENT_LENGTH_FROM_INCOMING); BasicHttpEntity entity = (BasicHttpEntity) response.getEntity(); MetricsCollector lstMetrics = worker.getServiceHandler().getMetrics(); try { if (forceContentLength) { entity.setChunked(false); if (forceContentLengthCopy && contentLength > 0) { entity.setContentLength(contentLength); } else { setStreamAsTempData(entity, messageFormatter, msgContext, format); } } worker.getServiceHandler().commitResponse(worker.getConn(), response); lstMetrics.reportResponseCode(response.getStatusLine().getStatusCode()); OutputStream out = worker.getOutputStream(); /* * if this is a dummy message to handle http 202 case with non-blocking IO * write an empty byte array as body */ if (msgContext.isPropertyTrue(NhttpConstants.SC_ACCEPTED) || Boolean.TRUE == noEntityBody) { out.write(new byte[0]); } else { if (forceContentLength) { if (forceContentLengthCopy && contentLength > 0) { messageFormatter.writeTo(msgContext, format, out, false); } else { writeMessageFromTempData(out, msgContext); } } else { messageFormatter.writeTo(msgContext, format, out, false); } } out.close(); if (lstMetrics != null) { lstMetrics.incrementMessagesSent(); } } catch (ProtocolException e) { log.error(e + " (Synapse may be trying to send an exact response more than once )"); } catch (HttpException e) { if (lstMetrics != null) { lstMetrics.incrementFaultsSending(); } handleException( "Unexpected HTTP protocol error sending response to : " + worker.getRemoteAddress(), e); } catch (ConnectionClosedException e) { if (lstMetrics != null) { lstMetrics.incrementFaultsSending(); } log.warn("Connection closed by client : " + worker.getRemoteAddress()); } catch (IllegalStateException e) { if (lstMetrics != null) { lstMetrics.incrementFaultsSending(); } log.warn("Connection closed by client : " + worker.getRemoteAddress()); } catch (IOException e) { if (lstMetrics != null) { lstMetrics.incrementFaultsSending(); } handleException("IO Error sending response message to : " + worker.getRemoteAddress(), e); } catch (Exception e) { if (lstMetrics != null) { lstMetrics.incrementFaultsSending(); } handleException( "General Error sending response message to : " + worker.getRemoteAddress(), e); } InputStream is = worker.getIs(); if (is != null) { try { is.close(); } catch (IOException ignore) { } } }