Examples with ParseException javax.mail.internet.ParseException used on opensource projects

Example 26 with ParseException

use of javax.mail.internet.ParseException in project rest.li by linkedin.

the class RestResponseDecoder method decodeResponse.

public void decodeResponse(final StreamResponse streamResponse, final Callback<Response<T>> responseCallback) throws RestLiDecodingException {
    // Determine content type and take appropriate action.
    // If 'multipart/related', then use MultiPartMIMEReader to read first part (which can be json or pson).
    final String contentTypeString = streamResponse.getHeader(RestConstants.HEADER_CONTENT_TYPE);
    if (contentTypeString != null) {
        ContentType contentType = null;
        try {
            contentType = new ContentType(contentTypeString);
        } catch (ParseException parseException) {
            responseCallback.onError(new RestLiDecodingException("Could not decode Content-Type header in response", parseException));
            return;
        }
        if (contentType.getBaseType().equalsIgnoreCase(RestConstants.HEADER_VALUE_MULTIPART_RELATED)) {
            final MultiPartMIMEReader multiPartMIMEReader = MultiPartMIMEReader.createAndAcquireStream(streamResponse);
            final TopLevelReaderCallback topLevelReaderCallback = new TopLevelReaderCallback(responseCallback, streamResponse, multiPartMIMEReader);
            multiPartMIMEReader.registerReaderCallback(topLevelReaderCallback);
            return;
        }
    }
    // Otherwise if the whole body is json/pson then read everything in.
    StreamDataCodec streamDataCodec = null;
    try {
        streamDataCodec = getContentType(streamResponse.getHeaders().get(RestConstants.HEADER_CONTENT_TYPE)).orElse(JSON).getStreamCodec();
    } catch (MimeTypeParseException e) {
        responseCallback.onError(e);
        return;
    }
    if (streamDataCodec != null) {
        CompletionStage<DataMap> dataMapCompletionStage = streamDataCodec.decodeMap(EntityStreamAdapters.toGenericEntityStream(streamResponse.getEntityStream()));
        dataMapCompletionStage.handle((dataMap, e) -> {
            if (e != null) {
                responseCallback.onError(new RestLiDecodingException("Could not decode REST response", e));
                return null;
            }
            try {
                responseCallback.onSuccess(createResponse(streamResponse.getHeaders(), streamResponse.getStatus(), dataMap, streamResponse.getCookies()));
            } catch (Throwable throwable) {
                responseCallback.onError(throwable);
            }
            // handle function requires a return statement although there is no more completion stage.
            return null;
        });
    } else {
        final FullEntityReader fullEntityReader = new FullEntityReader(new Callback<ByteString>() {

            @Override
            public void onError(Throwable e) {
                responseCallback.onError(e);
            }

            @Override
            public void onSuccess(ByteString result) {
                try {
                    responseCallback.onSuccess(createResponse(streamResponse.getHeaders(), streamResponse.getStatus(), result, streamResponse.getCookies()));
                } catch (Exception exception) {
                    onError(exception);
                }
            }
        });
        streamResponse.getEntityStream().setReader(fullEntityReader);
    }
}

Example 27 with ParseException

use of javax.mail.internet.ParseException in project rest.li by linkedin.

the class TestRestLiServer method testMultipartRelatedRequestNoUserAttachments.

@Test
public void testMultipartRelatedRequestNoUserAttachments() throws Exception {
    // This test verifies the server's ability to handle a multipart related request that has only one part which is
    // the rest.li payload; meaning there are no user defined attachments. Technically the client builders shouldn't do
    // this but we allow this to keep the protocol somewhat flexible.
    final AsyncStatusCollectionResource statusResource = getMockResource(AsyncStatusCollectionResource.class);
    statusResource.streamingAction(EasyMock.<String>anyObject(), EasyMock.<RestLiAttachmentReader>anyObject(), EasyMock.<Callback<Long>>anyObject());
    EasyMock.expectLastCall().andAnswer(new IAnswer<Object>() {

        @Override
        public Object answer() throws Throwable {
            // Verify there are no attachments.
            final RestLiAttachmentReader attachmentReader = (RestLiAttachmentReader) EasyMock.getCurrentArguments()[1];
            Assert.assertNull(attachmentReader);
            // Verify the action param.
            Assert.assertEquals((String) EasyMock.getCurrentArguments()[0], "someMetadata");
            // Now respond back to the request.
            @SuppressWarnings("unchecked") Callback<Long> callback = (Callback<Long>) EasyMock.getCurrentArguments()[2];
            callback.onSuccess(1234l);
            return null;
        }
    });
    replay(statusResource);
    // Now we create a multipart/related payload.
    final String payload = "{\"metadata\": \"someMetadata\"}";
    final ByteStringWriter byteStringWriter = new ByteStringWriter(ByteString.copyString(payload, Charset.defaultCharset()));
    final MultiPartMIMEWriter.Builder builder = new MultiPartMIMEWriter.Builder();
    final MultiPartMIMEWriter writer = AttachmentUtils.createMultiPartMIMEWriter(byteStringWriter, "application/json", builder);
    final StreamRequest streamRequest = MultiPartMIMEStreamRequestFactory.generateMultiPartMIMEStreamRequest(new URI("/asyncstatuses/?action=streamingAction"), "related", writer, Collections.<String, String>emptyMap(), "POST", ImmutableMap.of(RestConstants.HEADER_ACCEPT, RestConstants.HEADER_VALUE_MULTIPART_RELATED), Collections.emptyList());
    final Callback<StreamResponse> callback = new Callback<StreamResponse>() {

        @Override
        public void onSuccess(StreamResponse streamResponse) {
            Messages.toRestResponse(streamResponse, new Callback<RestResponse>() {

                @Override
                public void onError(Throwable e) {
                    Assert.fail();
                }

                @Override
                public void onSuccess(RestResponse result) {
                    Assert.assertEquals(result.getStatus(), 200);
                    try {
                        ContentType contentType = new ContentType(streamResponse.getHeader(RestConstants.HEADER_CONTENT_TYPE));
                        Assert.assertEquals(contentType.getBaseType(), RestConstants.HEADER_VALUE_APPLICATION_JSON);
                    } catch (ParseException parseException) {
                        Assert.fail();
                    }
                    // Verify the response body
                    Assert.assertEquals(result.getEntity().asAvroString(), "{\"value\":1234}");
                    EasyMock.verify(statusResource);
                    EasyMock.reset(statusResource);
                }
            });
        }

        @Override
        public void onError(Throwable e) {
            fail();
        }
    };
    _server.handleRequest(streamRequest, new RequestContext(), callback);
}

Example 28 with ParseException

use of javax.mail.internet.ParseException in project rest.li by linkedin.

the class TestRestLiServer method testRequestAttachmentsAndResponseAttachments.

@Test
public void testRequestAttachmentsAndResponseAttachments() throws Exception {
    // This test verifies the server's ability to accept request attachments and send back response attachments. This is the
    // main test to verify the wire protocol for streaming. We send a payload that contains the rest.li payload and some attachments
    // and we send a response back with a rest.li payload and some attachments.
    // Define the server side resource attachments to be sent back.
    final RestLiResponseAttachments.Builder responseAttachmentsBuilder = new RestLiResponseAttachments.Builder();
    responseAttachmentsBuilder.appendSingleAttachment(new RestLiTestAttachmentDataSource("1", ByteString.copyString("one", Charset.defaultCharset())));
    Capture<ResourceContext> resourceContextCapture = EasyMock.newCapture();
    final AsyncStatusCollectionResource statusResource = getMockResource(AsyncStatusCollectionResource.class, capture(resourceContextCapture));
    statusResource.streamingAction(EasyMock.<String>anyObject(), EasyMock.<RestLiAttachmentReader>anyObject(), EasyMock.<Callback<Long>>anyObject());
    EasyMock.expectLastCall().andAnswer(new IAnswer<Object>() {

        @Override
        public Object answer() throws Throwable {
            // Verify there are still attachments to be read.
            final RestLiAttachmentReader attachmentReader = (RestLiAttachmentReader) EasyMock.getCurrentArguments()[1];
            Assert.assertFalse(attachmentReader.haveAllAttachmentsFinished());
            // Verify the action param.
            Assert.assertEquals((String) EasyMock.getCurrentArguments()[0], "someMetadata");
            // Set the response attachments
            resourceContextCapture.getValue().setResponseAttachments(responseAttachmentsBuilder.build());
            // Now respond back to the request.
            @SuppressWarnings("unchecked") Callback<Long> callback = (Callback<Long>) EasyMock.getCurrentArguments()[2];
            callback.onSuccess(1234l);
            return null;
        }
    });
    replay(statusResource);
    // Now we create a multipart/related payload.
    final String payload = "{\"metadata\": \"someMetadata\"}";
    final ByteStringWriter byteStringWriter = new ByteStringWriter(ByteString.copyString(payload, Charset.defaultCharset()));
    final MultiPartMIMEWriter.Builder builder = new MultiPartMIMEWriter.Builder();
    AttachmentUtils.appendSingleAttachmentToBuilder(builder, new RestLiTestAttachmentDataSource("2", ByteString.copyString("two", Charset.defaultCharset())));
    final MultiPartMIMEWriter writer = AttachmentUtils.createMultiPartMIMEWriter(byteStringWriter, "application/json", builder);
    final StreamRequest streamRequest = MultiPartMIMEStreamRequestFactory.generateMultiPartMIMEStreamRequest(new URI("/asyncstatuses/?action=streamingAction"), "related", writer, Collections.<String, String>emptyMap(), "POST", ImmutableMap.of(RestConstants.HEADER_ACCEPT, RestConstants.HEADER_VALUE_MULTIPART_RELATED), Collections.emptyList());
    final Callback<StreamResponse> callback = new Callback<StreamResponse>() {

        @Override
        public void onSuccess(StreamResponse streamResponse) {
            // Before reading the data make sure top level type is multipart/related
            Assert.assertEquals(streamResponse.getStatus(), 200);
            try {
                ContentType contentType = new ContentType(streamResponse.getHeader(RestConstants.HEADER_CONTENT_TYPE));
                Assert.assertEquals(contentType.getBaseType(), RestConstants.HEADER_VALUE_MULTIPART_RELATED);
            } catch (ParseException parseException) {
                Assert.fail();
            }
            final CountDownLatch countDownLatch = new CountDownLatch(1);
            MultiPartMIMEFullReaderCallback fullReaderCallback = new MultiPartMIMEFullReaderCallback(countDownLatch);
            final MultiPartMIMEReader reader = MultiPartMIMEReader.createAndAcquireStream(streamResponse);
            reader.registerReaderCallback(fullReaderCallback);
            try {
                countDownLatch.await(3000, TimeUnit.MILLISECONDS);
            } catch (InterruptedException interruptedException) {
                Assert.fail();
            }
            final List<SinglePartMIMEFullReaderCallback> singlePartMIMEReaderCallbacks = fullReaderCallback.getSinglePartMIMEReaderCallbacks();
            Assert.assertEquals(singlePartMIMEReaderCallbacks.size(), 2);
            // Verify first part is Action response.
            Assert.assertEquals(singlePartMIMEReaderCallbacks.get(0).getHeaders().get(RestConstants.HEADER_CONTENT_TYPE), RestConstants.HEADER_VALUE_APPLICATION_JSON);
            Assert.assertEquals(singlePartMIMEReaderCallbacks.get(0).getFinishedData().asAvroString(), "{\"value\":1234}");
            // Verify the second part matches what the server should have sent back
            Assert.assertEquals(singlePartMIMEReaderCallbacks.get(1).getHeaders().get(RestConstants.HEADER_CONTENT_ID), "1");
            Assert.assertEquals(singlePartMIMEReaderCallbacks.get(1).getFinishedData().asString(Charset.defaultCharset()), "one");
            EasyMock.verify(statusResource);
            EasyMock.reset(statusResource);
        }

        @Override
        public void onError(Throwable e) {
            fail();
        }
    };
    _server.handleRequest(streamRequest, new RequestContext(), callback);
}

Example 29 with ParseException

use of javax.mail.internet.ParseException in project wso2-synapse by wso2.

the class Axis2FlexibleMEPClient method send.

/**
 * 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 {
    if (synapseOutMessageContext.getProperty(SynapseConstants.BLOCKING_MSG_SENDER) != null) {
        BlockingMsgSender blockingMsgSender = (BlockingMsgSender) synapseOutMessageContext.getProperty(SynapseConstants.BLOCKING_MSG_SENDER);
        blockingMsgSender.send(endpoint, synapseOutMessageContext);
        return;
    }
    boolean separateListener = false;
    boolean wsSecurityEnabled = false;
    String wsSecPolicyKey = null;
    String inboundWsSecPolicyKey = null;
    String outboundWsSecPolicyKey = null;
    boolean wsRMEnabled = false;
    boolean wsAddressingEnabled = false;
    String wsAddressingVersion = null;
    if (endpoint != null) {
        separateListener = endpoint.isUseSeparateListener();
        wsSecurityEnabled = endpoint.isSecurityOn();
        wsSecPolicyKey = endpoint.getWsSecPolicyKey();
        inboundWsSecPolicyKey = endpoint.getInboundWsSecPolicyKey();
        outboundWsSecPolicyKey = endpoint.getOutboundWsSecPolicyKey();
        wsAddressingEnabled = endpoint.isAddressingOn();
        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 + (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);
    }
    if (originalInMsgCtx.getProperty(CorrelationConstants.CORRELATION_ID) == null) {
        originalInMsgCtx.setProperty(CorrelationConstants.CORRELATION_ID, UUID.randomUUID().toString());
    }
    if (headers == null) {
        headers = new HashMap();
        originalInMsgCtx.setProperty(MessageContext.TRANSPORT_HEADERS, headers);
    }
    Object status = originalInMsgCtx.getProperty(NhttpConstants.ACTIVITY_ID_STATUS);
    if ((status != null) && ((boolean) status)) {
        headers.put(PassThroughConfiguration.getInstance().getCorrelationHeaderName(), originalInMsgCtx.getProperty(CorrelationConstants.CORRELATION_ID).toString());
    }
    // 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);
    // set "INTERNAL_TRANSACTION_COUNTED" property in axisOutMsgCtx's message context.
    axisOutMsgCtx.setProperty(BaseConstants.INTERNAL_TRANSACTION_COUNTED, originalInMsgCtx.getProperty(BaseConstants.INTERNAL_TRANSACTION_COUNTED));
    Object TRIGGER_NAME;
    if ((TRIGGER_NAME = synapseOutMessageContext.getProperty(SynapseConstants.PROXY_SERVICE)) != null) {
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_TYPE, SynapseConstants.PROXY_SERVICE_TYPE);
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_NAME, TRIGGER_NAME.toString());
    } else if ((TRIGGER_NAME = synapseOutMessageContext.getProperty(RESTConstants.SYNAPSE_REST_API)) != null) {
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_TYPE, SynapseConstants.FAIL_SAFE_MODE_API);
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_NAME, TRIGGER_NAME.toString());
    } else if ((TRIGGER_NAME = synapseOutMessageContext.getProperty(SynapseConstants.INBOUND_ENDPOINT_NAME)) != null) {
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_TYPE, SynapseConstants.FAIL_SAFE_MODE_INBOUND_ENDPOINT);
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_NAME, TRIGGER_NAME.toString());
    } else {
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_TYPE, "anonymous");
        axisOutMsgCtx.setProperty(PassThroughConstants.INTERNAL_TRIGGER_NAME, "anonymous");
    }
    if (log.isDebugEnabled()) {
        log.debug("Message [Original Request Message ID : " + synapseOutMessageContext.getMessageID() + "]" + " [New Cloned Request Message ID : " + axisOutMsgCtx.getMessageID() + "]");
    }
    // so that we can use the original message context for resending through different endpoints
    if (endpoint != null) {
        // get the endpoint encoding attribute
        String strCharSetEncoding = "";
        if (endpoint.getCharSetEncoding() != null) {
            strCharSetEncoding = ";" + endpoint.getCharSetEncoding();
        }
        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 + strCharSetEncoding);
            }
        } 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 the incoming is rest, then message need to be serialized prior to the conversion.
            if (originalInMsgCtx.isDoingREST()) {
                try {
                    MediatorPropertyUtils.serializeOMElement(synapseOutMessageContext);
                } catch (Exception e) {
                    handleException("Error while serializing the  message", e);
                }
            }
            if (!axisOutMsgCtx.isSOAP11()) {
                SOAPUtils.convertSOAP12toSOAP11(axisOutMsgCtx);
            }
            Object o = axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS);
            Map transportHeaders = (Map) o;
            if (transportHeaders != null) {
                // Fix ESBJAVA-3645 Should not do this for multipart/related
                String trpContentType = (String) transportHeaders.get(HTTP.CONTENT_TYPE);
                // if content type is not found, setting the content type
                if (trpContentType == null) {
                    transportHeaders.put(HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_TEXT_XML + strCharSetEncoding);
                } else if (!trpContentType.contains(PassThroughConstants.CONTENT_TYPE_MULTIPART_RELATED)) {
                    transportHeaders.remove(HTTP.CONTENT_TYPE);
                    try {
                        // ESBJAVA-3447, Appending charset, if exist in property
                        ContentType contentType = new ContentType(trpContentType);
                        if (contentType.getParameter(HTTPConstants.CHAR_SET_ENCODING) != null) {
                            strCharSetEncoding = "; charset=" + contentType.getParameter(HTTPConstants.CHAR_SET_ENCODING);
                        }
                    } catch (ParseException e) {
                        log.warn("Error occurred while parsing ContentType header, using default: " + HTTPConstants.MEDIA_TYPE_TEXT_XML);
                    }
                    transportHeaders.put(HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_TEXT_XML + strCharSetEncoding);
                }
            }
        } 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 transportHeaders = (Map) o;
            if (transportHeaders != null) {
                // Fix ESBJAVA-3645 Should not do this for multipart/related
                String trpContentType = (String) transportHeaders.get(HTTP.CONTENT_TYPE);
                // if content type is not found, setting the content type
                if (trpContentType == null) {
                    transportHeaders.put(HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML + strCharSetEncoding);
                } else if (!trpContentType.contains(PassThroughConstants.CONTENT_TYPE_MULTIPART_RELATED)) {
                    transportHeaders.remove(HTTP.CONTENT_TYPE);
                    try {
                        // ESBJAVA-3447, Appending charset, if exist in property
                        ContentType contentType = new ContentType(trpContentType);
                        if (contentType.getParameter(HTTPConstants.CHAR_SET_ENCODING) != null) {
                            strCharSetEncoding = "; charset=" + contentType.getParameter(HTTPConstants.CHAR_SET_ENCODING);
                        }
                    } catch (ParseException e) {
                        log.warn("Error occurred while parsing ContentType header in property, using default: " + HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML);
                    }
                    if (axisOutMsgCtx.getSoapAction() != null) {
                        String actionHeaderPrefix = ";action=\"";
                        String contentTypeWithAction = new StringBuilder(org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML.length() + axisOutMsgCtx.getSoapAction().length() + actionHeaderPrefix.length() + 1).append(org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML).append(actionHeaderPrefix).append(axisOutMsgCtx.getSoapAction()).append('\"').toString();
                        transportHeaders.put(HTTP.CONTENT_TYPE, contentTypeWithAction + strCharSetEncoding);
                    } else {
                        transportHeaders.put(HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML + strCharSetEncoding);
                    }
                }
            }
        } else if (SynapseConstants.FORMAT_REST.equals(endpoint.getFormat())) {
            /* 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);
            // Remove the Content-Type transport header if it is not multipart/related to honor the content
            // type extracted from the SOAPMessageFormatter
            Object trpHeaders = axisOutMsgCtx.getProperty(MessageContext.TRANSPORT_HEADERS);
            if (trpHeaders != null && trpHeaders instanceof Map && ((Map) trpHeaders).get(HTTPConstants.HEADER_CONTENT_TYPE) != null && !isMultipartContent(((Map) trpHeaders).get(HTTPConstants.HEADER_CONTENT_TYPE).toString())) {
                ((Map) trpHeaders).remove(HTTPConstants.HEADER_CONTENT_TYPE);
            }
        } 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());
        }
        // 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 {
                    if (!address.startsWith("jms")) {
                        url = address + restSuffix;
                    } else {
                        url = address;
                    }
                }
                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));
                }
            }
        }
        // Update To url if mock-service exists for unit test
        MediatorPropertyUtils.updateSendToUrlForMockServices(endpoint, synapseOutMessageContext, axisOutMsgCtx);
        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 security is enabled,
    if (wsSecurityEnabled) {
        // if a WS-Sec policy is specified, use it
        if (wsSecPolicyKey != null) {
            if (endpoint.isDynamicPolicy()) {
                wsSecPolicyKey = endpoint.evaluateDynamicEndpointSecurityPolicy(synapseOutMessageContext);
            }
            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.getEffectiveTimeout() > 0) {
        if (!endpoint.isDynamicTimeoutEndpoint()) {
            axisOutMsgCtx.setProperty(SynapseConstants.SEND_TIMEOUT, endpoint.getEffectiveTimeout());
        } else {
            axisOutMsgCtx.setProperty(SynapseConstants.SEND_TIMEOUT, endpoint.evaluateDynamicEndpointTimeout(synapseOutMessageContext));
        }
    }
    // 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) {
            // TimeoutHandler can detect timed out callbacks and take appropriate action.
            if (!endpoint.isDynamicTimeoutEndpoint()) {
                long endpointTimeout = endpoint.getEffectiveTimeout();
                callback.setTimeout(endpointTimeout);
                callback.setTimeOutAction(endpoint.getTimeoutAction());
                callback.setTimeoutType(endpoint.getEndpointTimeoutType());
                if (log.isDebugEnabled()) {
                    log.debug("Setting Timeout for endpoint : " + getEndpointLogMessage(synapseOutMessageContext, axisOutMsgCtx) + " to static timeout value : " + endpointTimeout);
                }
            } else {
                long endpointTimeout = endpoint.evaluateDynamicEndpointTimeout(synapseOutMessageContext);
                callback.setTimeout(endpointTimeout);
                callback.setTimeOutAction(endpoint.getTimeoutAction());
                callback.setTimeoutType(endpoint.getEndpointTimeoutType());
                if (log.isDebugEnabled()) {
                    log.debug("Setting Timeout for endpoint : " + getEndpointLogMessage(synapseOutMessageContext, axisOutMsgCtx) + " to dynamic timeout value : " + endpointTimeout);
                }
            }
        } else {
            long globalTimeout = synapseOutMessageContext.getEnvironment().getGlobalTimeout();
            callback.setTimeout(globalTimeout);
            callback.setTimeoutType(SynapseConstants.ENDPOINT_TIMEOUT_TYPE.GLOBAL_TIMEOUT);
            if (log.isDebugEnabled()) {
                log.debug("Setting timeout for implicit endpoint : " + getEndpointLogMessage(synapseOutMessageContext, axisOutMsgCtx) + " to global timeout value of " + globalTimeout);
            }
        }
    }
    mepClient.setCallback(callback);
    // 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);
    }
    // clear the message context properties related to endpoint in last service invocation
    Set keySet = synapseOutMessageContext.getPropertyKeySet();
    if (keySet != null) {
        keySet.remove(EndpointDefinition.DYNAMIC_URL_VALUE);
    }
    // throttling count for OUT_ONLY messages
    if (outOnlyMessage) {
        Boolean isConcurrencyThrottleEnabled = (Boolean) synapseOutMessageContext.getProperty(SynapseConstants.SYNAPSE_CONCURRENCY_THROTTLE);
        if (isConcurrencyThrottleEnabled != null && isConcurrencyThrottleEnabled) {
            ConcurrentAccessController concurrentAccessController = (ConcurrentAccessController) synapseOutMessageContext.getProperty(SynapseConstants.SYNAPSE_CONCURRENT_ACCESS_CONTROLLER);
            int available = concurrentAccessController.incrementAndGet();
            int concurrentLimit = concurrentAccessController.getLimit();
            if (log.isDebugEnabled()) {
                log.debug("Concurrency Throttle : Connection returned" + " :: " + available + " of available of " + concurrentLimit + " connections");
            }
            ConcurrentAccessReplicator concurrentAccessReplicator = (ConcurrentAccessReplicator) synapseOutMessageContext.getProperty(SynapseConstants.SYNAPSE_CONCURRENT_ACCESS_REPLICATOR);
            String throttleKey = (String) synapseOutMessageContext.getProperty(SynapseConstants.SYNAPSE_CONCURRENCY_THROTTLE_KEY);
            if (concurrentAccessReplicator != null) {
                concurrentAccessReplicator.replicate(throttleKey, true);
            }
        }
    }
    mepClient.execute(true);
}