Examples with RuntimeCamelException org.apache.camel.RuntimeCamelException used on opensource projects

Example 21 with RuntimeCamelException

use of org.apache.camel.RuntimeCamelException in project camel by apache.

the class DefaultRestletBinding method populateRestletRequestFromExchange.

public void populateRestletRequestFromExchange(Request request, Exchange exchange) {
    request.setReferrerRef("camel-restlet");
    final Method method = request.getMethod();
    MediaType mediaType = exchange.getIn().getHeader(Exchange.CONTENT_TYPE, MediaType.class);
    if (mediaType == null) {
        mediaType = MediaType.APPLICATION_WWW_FORM;
    }
    Form form = null;
    // Use forms only for PUT, POST and x-www-form-urlencoded
    if ((Method.PUT == method || Method.POST == method) && MediaType.APPLICATION_WWW_FORM.equals(mediaType, true)) {
        form = new Form();
        if (exchange.getIn().getBody() instanceof Map) {
            //Body is key value pairs
            try {
                Map pairs = exchange.getIn().getBody(Map.class);
                for (Object key : pairs.keySet()) {
                    Object value = pairs.get(key);
                    form.add(key.toString(), value != null ? value.toString() : null);
                }
            } catch (Exception e) {
                throw new RuntimeCamelException("body for " + MediaType.APPLICATION_WWW_FORM + " request must be Map<String,String> or string format like name=bob&password=secRet", e);
            }
        } else {
            // use string based for forms
            String body = exchange.getIn().getBody(String.class);
            if (body != null) {
                List<NameValuePair> pairs = URLEncodedUtils.parse(body, Charset.forName(IOHelper.getCharsetName(exchange, true)));
                for (NameValuePair p : pairs) {
                    form.add(p.getName(), p.getValue());
                }
            }
        }
    }
    // get outgoing custom http headers from the exchange if they exists
    Series<Header> restletHeaders = exchange.getIn().getHeader(HeaderConstants.ATTRIBUTE_HEADERS, Series.class);
    if (restletHeaders == null) {
        restletHeaders = new Series<Header>(Header.class);
        request.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, restletHeaders);
    } else {
        // if the restlet headers already exists on the exchange, we need to filter them
        for (String name : restletHeaders.getNames()) {
            if (headerFilterStrategy.applyFilterToCamelHeaders(name, restletHeaders.getValues(name), exchange)) {
                restletHeaders.removeAll(name);
            }
        }
        request.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, restletHeaders);
        // since the restlet headers already exists remove them from the exchange so they don't get added again below
        // we will get a new set of restlet headers on the response
        exchange.getIn().removeHeader(HeaderConstants.ATTRIBUTE_HEADERS);
    }
    // login and password are filtered by header filter strategy
    String login = exchange.getIn().getHeader(RestletConstants.RESTLET_LOGIN, String.class);
    String password = exchange.getIn().getHeader(RestletConstants.RESTLET_PASSWORD, String.class);
    if (login != null && password != null) {
        ChallengeResponse authentication = new ChallengeResponse(ChallengeScheme.HTTP_BASIC, login, password);
        request.setChallengeResponse(authentication);
        LOG.debug("Basic HTTP Authentication has been applied");
    }
    for (Map.Entry<String, Object> entry : exchange.getIn().getHeaders().entrySet()) {
        String key = entry.getKey();
        Object value = entry.getValue();
        if (!headerFilterStrategy.applyFilterToCamelHeaders(key, value, exchange)) {
            // Use forms only for PUT, POST and x-www-form-urlencoded
            if (form != null) {
                if (key.startsWith("org.restlet.")) {
                    // put the org.restlet headers in attributes
                    request.getAttributes().put(key, value);
                } else {
                    // put the user stuff in the form
                    if (value instanceof Collection) {
                        for (Object v : (Collection<?>) value) {
                            form.add(key, v.toString());
                            if (!headerFilterStrategy.applyFilterToCamelHeaders(key, value, exchange)) {
                                restletHeaders.set(key, value.toString());
                            }
                        }
                    } else {
                        //Add headers to headers and to body
                        form.add(key, value.toString());
                        if (!headerFilterStrategy.applyFilterToCamelHeaders(key, value, exchange)) {
                            restletHeaders.set(key, value.toString());
                        }
                    }
                }
            } else {
                // For non-form post put all the headers in custom headers
                if (!headerFilterStrategy.applyFilterToCamelHeaders(key, value, exchange)) {
                    restletHeaders.set(key, value.toString());
                }
            }
            LOG.debug("Populate Restlet request from exchange header: {} value: {}", key, value);
        }
    }
    if (form != null) {
        request.setEntity(form.getWebRepresentation());
        LOG.debug("Populate Restlet {} request from exchange body as form using media type {}", method, mediaType);
    } else {
        // include body if PUT or POST
        if (request.getMethod() == Method.PUT || request.getMethod() == Method.POST) {
            Representation body = createRepresentationFromBody(exchange, mediaType);
            request.setEntity(body);
            LOG.debug("Populate Restlet {} request from exchange body: {} using media type {}", method, body, mediaType);
        } else {
            // no body
            LOG.debug("Populate Restlet {} request from exchange using media type {}", method, mediaType);
            request.setEntity(new EmptyRepresentation());
        }
    }
    // accept
    String accept = exchange.getIn().getHeader("Accept", String.class);
    final ClientInfo clientInfo = request.getClientInfo();
    final List<Preference<MediaType>> acceptedMediaTypesList = clientInfo.getAcceptedMediaTypes();
    if (accept != null) {
        final MediaType[] acceptedMediaTypes = exchange.getContext().getTypeConverter().tryConvertTo(MediaType[].class, exchange, accept);
        for (final MediaType acceptedMediaType : acceptedMediaTypes) {
            acceptedMediaTypesList.add(new Preference<MediaType>(acceptedMediaType));
        }
    }
    final MediaType[] acceptedMediaTypes = exchange.getIn().getHeader(Exchange.ACCEPT_CONTENT_TYPE, MediaType[].class);
    if (acceptedMediaTypes != null) {
        for (final MediaType acceptedMediaType : acceptedMediaTypes) {
            acceptedMediaTypesList.add(new Preference<MediaType>(acceptedMediaType));
        }
    }
}

Example 22 with RuntimeCamelException

use of org.apache.camel.RuntimeCamelException in project camel by apache.

the class AbstractMessageHandler method onMessage.

/*
     * @see javax.jms.MessageListener#onMessage(javax.jms.Message)
     *
     * @param message
     */
@Override
public void onMessage(Message message) {
    RuntimeCamelException rce = null;
    try {
        final Exchange exchange = getEndpoint().createExchange(message, getSession());
        log.debug("Processing Exchange.id:{}", exchange.getExchangeId());
        if (isTransacted()) {
            if (isSharedJMSSession()) {
                // Propagate a JMS Session as an initiator if sharedJMSSession is enabled
                exchange.getIn().setHeader(SjmsConstants.JMS_SESSION, getSession());
            }
        }
        try {
            if (isTransacted() || isSynchronous()) {
                log.debug("Handling synchronous message: {}", exchange.getIn().getBody());
                handleMessage(exchange);
                if (exchange.isFailed()) {
                    synchronization.onFailure(exchange);
                } else {
                    synchronization.onComplete(exchange);
                }
            } else {
                log.debug("Handling asynchronous message: {}", exchange.getIn().getBody());
                executor.execute(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            handleMessage(exchange);
                        } catch (Exception e) {
                            exchange.setException(e);
                        }
                    }
                });
            }
        } catch (Exception e) {
            if (exchange.getException() == null) {
                exchange.setException(e);
            } else {
                throw e;
            }
        }
    } catch (Exception e) {
        rce = wrapRuntimeCamelException(e);
    } finally {
        if (rce != null) {
            throw rce;
        }
    }
}

Example 23 with RuntimeCamelException

use of org.apache.camel.RuntimeCamelException in project camel by apache.

the class JmsBinding method extractHeadersFromJms.

public Map<String, Object> extractHeadersFromJms(Message jmsMessage, Exchange exchange) {
    Map<String, Object> map = new HashMap<String, Object>();
    if (jmsMessage != null) {
        // lets populate the standard JMS message headers
        try {
            map.put("JMSCorrelationID", jmsMessage.getJMSCorrelationID());
            map.put("JMSCorrelationIDAsBytes", JmsMessageHelper.getJMSCorrelationIDAsBytes(jmsMessage));
            map.put("JMSDeliveryMode", jmsMessage.getJMSDeliveryMode());
            map.put("JMSDestination", jmsMessage.getJMSDestination());
            map.put("JMSExpiration", jmsMessage.getJMSExpiration());
            map.put("JMSMessageID", jmsMessage.getJMSMessageID());
            map.put("JMSPriority", jmsMessage.getJMSPriority());
            map.put("JMSRedelivered", jmsMessage.getJMSRedelivered());
            map.put("JMSTimestamp", jmsMessage.getJMSTimestamp());
            map.put("JMSReplyTo", JmsMessageHelper.getJMSReplyTo(jmsMessage));
            map.put("JMSType", JmsMessageHelper.getJMSType(jmsMessage));
            // this works around a bug in the ActiveMQ property handling
            map.put(JmsConstants.JMSX_GROUP_ID, JmsMessageHelper.getStringProperty(jmsMessage, JmsConstants.JMSX_GROUP_ID));
            map.put("JMSXUserID", JmsMessageHelper.getStringProperty(jmsMessage, "JMSXUserID"));
        } catch (JMSException e) {
            throw new RuntimeCamelException(e);
        }
        Enumeration<?> names;
        try {
            names = jmsMessage.getPropertyNames();
        } catch (JMSException e) {
            throw new RuntimeCamelException(e);
        }
        while (names.hasMoreElements()) {
            String name = names.nextElement().toString();
            try {
                Object value = JmsMessageHelper.getProperty(jmsMessage, name);
                if (headerFilterStrategy != null && headerFilterStrategy.applyFilterToExternalHeaders(name, value, exchange)) {
                    continue;
                }
                // must decode back from safe JMS header name to original header name
                // when storing on this Camel JmsMessage object.
                String key = jmsJmsKeyFormatStrategy.decodeKey(name);
                map.put(key, value);
            } catch (JMSException e) {
                throw new RuntimeCamelException(name, e);
            }
        }
    }
    return map;
}

Example 24 with RuntimeCamelException

use of org.apache.camel.RuntimeCamelException in project camel by apache.

the class JmsBinding method extractBodyFromJms.

/**
     * Extracts the body from the JMS message
     *
     * @param exchange the exchange
     * @param message  the message to extract its body
     * @return the body, can be <tt>null</tt>
     */
public Object extractBodyFromJms(Exchange exchange, Message message) {
    try {
        // if we are configured to not map the jms message then return it as body
        if (!mapJmsMessage) {
            LOG.trace("Option map JMS message is false so using JMS message as body: {}", message);
            return message;
        }
        if (message instanceof ObjectMessage) {
            LOG.trace("Extracting body as a ObjectMessage from JMS message: {}", message);
            ObjectMessage objectMessage = (ObjectMessage) message;
            Object payload = objectMessage.getObject();
            if (payload instanceof DefaultExchangeHolder) {
                DefaultExchangeHolder holder = (DefaultExchangeHolder) payload;
                DefaultExchangeHolder.unmarshal(exchange, holder);
                return exchange.getIn().getBody();
            } else {
                return objectMessage.getObject();
            }
        } else if (message instanceof TextMessage) {
            LOG.trace("Extracting body as a TextMessage from JMS message: {}", message);
            TextMessage textMessage = (TextMessage) message;
            return textMessage.getText();
        } else if (message instanceof MapMessage) {
            LOG.trace("Extracting body as a MapMessage from JMS message: {}", message);
            return createMapFromMapMessage((MapMessage) message);
        } else if (message instanceof BytesMessage) {
            LOG.trace("Extracting body as a BytesMessage from JMS message: {}", message);
            return createByteArrayFromBytesMessage((BytesMessage) message);
        } else if (message instanceof StreamMessage) {
            LOG.trace("Extracting body as a StreamMessage from JMS message: {}", message);
            return message;
        } else {
            return null;
        }
    } catch (JMSException e) {
        throw new RuntimeCamelException("Failed to extract body due to: " + e + ". Message: " + message, e);
    }
}

Example 25 with RuntimeCamelException

use of org.apache.camel.RuntimeCamelException in project camel by apache.

the class Soap11DataFormatAdapter method createFaultFromException.

/**
     * Creates a SOAP fault from the exception and populates the message as well
     * as the detail. The detail object is read from the method getFaultInfo of
     * the throwable if present
     * 
     * @param exception the cause exception
     * @return SOAP fault from given Throwable
     */
@SuppressWarnings("unchecked")
private JAXBElement<Fault> createFaultFromException(final Throwable exception) {
    WebFault webFault = exception.getClass().getAnnotation(WebFault.class);
    if (webFault == null || webFault.targetNamespace() == null) {
        throw new RuntimeException("The exception " + exception.getClass().getName() + " needs to have an WebFault annotation with name and targetNamespace", exception);
    }
    QName name = new QName(webFault.targetNamespace(), webFault.name());
    Object faultObject;
    try {
        Method method = exception.getClass().getMethod("getFaultInfo");
        faultObject = method.invoke(exception);
    } catch (Exception e) {
        throw new RuntimeCamelException("Exception while trying to get fault details", e);
    }
    Fault fault = new Fault();
    fault.setFaultcode(FAULT_CODE_SERVER);
    fault.setFaultstring(exception.getMessage());
    Detail detailEl = new ObjectFactory().createDetail();
    @SuppressWarnings("rawtypes") JAXBElement<?> faultDetailContent = new JAXBElement(name, faultObject.getClass(), faultObject);
    detailEl.getAny().add(faultDetailContent);
    fault.setDetail(detailEl);
    return new ObjectFactory().createFault(fault);
}