camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [01/24] camel git commit: camel-http-common - as a common module
Date Thu, 23 Jul 2015 12:58:03 GMT
Repository: camel
Updated Branches:
  refs/heads/master 2a93d6e09 -> 5b63cf5a3


http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpHelper.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpHelper.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpHelper.java
new file mode 100644
index 0000000..d22ee6b
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpHelper.java
@@ -0,0 +1,429 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.Producer;
+import org.apache.camel.RuntimeExchangeException;
+import org.apache.camel.converter.IOConverter;
+import org.apache.camel.converter.stream.CachedOutputStream;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.util.CamelObjectInputStream;
+import org.apache.camel.util.IOHelper;
+import org.apache.camel.util.ObjectHelper;
+import org.apache.camel.util.URISupport;
+import org.apache.camel.util.UnsafeUriCharactersEncoder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class HttpHelper {
+
+    private static final Logger LOG = LoggerFactory.getLogger(HttpHelper.class);
+
+    private HttpHelper() {
+        // Helper class
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void setCharsetFromContentType(String contentType, Exchange exchange) {
+        if (contentType != null) {
+            // find the charset and set it to the Exchange
+            int index = contentType.indexOf("charset=");
+            if (index > 0) {
+                String charset = contentType.substring(index + 8);
+                exchange.setProperty(Exchange.CHARSET_NAME, IOConverter.normalizeCharset(charset));
+            }
+        }
+    }
+
+    public static String getCharsetFromContentType(String contentType) {
+        if (contentType != null) {
+            // find the charset and set it to the Exchange
+            int index = contentType.indexOf("charset=");
+            if (index > 0) {
+                String charset = contentType.substring(index + 8);
+                // there may be another parameter after a semi colon, so skip that
+                if (charset.contains(";")) {
+                    charset = ObjectHelper.before(charset, ";");
+                }
+                return IOHelper.normalizeCharset(charset);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Writes the given object as response body to the servlet response
+     * <p/>
+     * The content type will be set to {@link HttpConstants#CONTENT_TYPE_JAVA_SERIALIZED_OBJECT}
+     *
+     * @param response servlet response
+     * @param target   object to write
+     * @throws IOException is thrown if error writing
+     */
+    public static void writeObjectToServletResponse(ServletResponse response, Object target)
throws IOException {
+        response.setContentType(HttpConstants.CONTENT_TYPE_JAVA_SERIALIZED_OBJECT);
+        writeObjectToStream(response.getOutputStream(), target);
+    }
+
+    /**
+     * Writes the given object as response body to the output stream
+     *
+     * @param stream output stream
+     * @param target   object to write
+     * @throws IOException is thrown if error writing
+     */
+    public static void writeObjectToStream(OutputStream stream, Object target) throws IOException
{
+        ObjectOutputStream oos = new ObjectOutputStream(stream);
+        oos.writeObject(target);
+        oos.flush();
+        IOHelper.close(oos);
+    }
+
+    /**
+     * Deserializes the input stream to a Java object
+     *
+     * @param is input stream for the Java object
+     * @return the java object, or <tt>null</tt> if input stream was <tt>null</tt>
+     * @throws ClassNotFoundException is thrown if class not found
+     * @throws IOException can be thrown
+     * @deprecated Camel 3.0 
+     * Please use the one which has the parameter of camel context
+     */
+    @Deprecated
+    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException,
IOException {
+        return deserializeJavaObjectFromStream(is, null);
+    }
+    
+    /**
+     * Deserializes the input stream to a Java object
+     *
+     * @param is input stream for the Java object
+     * @param context the camel context which could help us to apply the customer classloader
+     * @return the java object, or <tt>null</tt> if input stream was <tt>null</tt>
+     * @throws ClassNotFoundException is thrown if class not found
+     * @throws IOException can be thrown
+     */
+    public static Object deserializeJavaObjectFromStream(InputStream is, CamelContext context)
throws ClassNotFoundException, IOException {
+        if (is == null) {
+            return null;
+        }
+
+        Object answer = null;
+        ObjectInputStream ois = new CamelObjectInputStream(is, context);
+        try {
+            answer = ois.readObject();
+        } finally {
+            IOHelper.close(ois);
+        }
+
+        return answer;
+    }
+
+    /**
+     * Reads the response body from the given http servlet request.
+     *
+     * @param request  http servlet request
+     * @param exchange the exchange
+     * @return the request body, can be <tt>null</tt> if no body
+     * @throws IOException is thrown if error reading response body
+     */
+    public static Object readRequestBodyFromServletRequest(HttpServletRequest request, Exchange
exchange) throws IOException {
+        InputStream is = HttpConverter.toInputStream(request, exchange);
+        return readResponseBodyFromInputStream(is, exchange);
+    }
+    
+    /**
+     * Reads the response body from the given input stream.
+     *
+     * @param is       the input stream
+     * @param exchange the exchange
+     * @return the response body, can be <tt>null</tt> if no body
+     * @throws IOException is thrown if error reading response body
+     */
+    public static Object readRequestBodyFromInputStream(InputStream is, Exchange exchange)
throws IOException {
+        if (is == null) {
+            return null;
+        }
+        boolean disableStreamCaching = false;
+        // Just take the consideration of the setting of Camel Context StreamCaching
+        if (exchange.getContext() instanceof DefaultCamelContext) { 
+            DefaultCamelContext context = (DefaultCamelContext) exchange.getContext();
+            disableStreamCaching = !context.isStreamCaching();
+        }
+        // convert the input stream to StreamCache if the stream cache is not disabled
+        if (exchange.getProperty(Exchange.DISABLE_HTTP_STREAM_CACHE, disableStreamCaching,
Boolean.class)) {
+            return is;
+        } else {
+            CachedOutputStream cos = new CachedOutputStream(exchange);
+            IOHelper.copyAndCloseInput(is, cos);
+            return cos.newStreamCache();
+        }
+    }
+
+
+    /**
+     * Reads the response body from the given input stream.
+     *
+     * @param is       the input stream
+     * @param exchange the exchange
+     * @return the response body, can be <tt>null</tt> if no body
+     * @throws IOException is thrown if error reading response body
+     */
+    public static Object readResponseBodyFromInputStream(InputStream is, Exchange exchange)
throws IOException {
+        if (is == null) {
+            return null;
+        }
+        // convert the input stream to StreamCache if the stream cache is not disabled
+        if (exchange.getProperty(Exchange.DISABLE_HTTP_STREAM_CACHE, Boolean.FALSE, Boolean.class))
{
+            return is;
+        } else {
+            CachedOutputStream cos = new CachedOutputStream(exchange);
+            IOHelper.copyAndCloseInput(is, cos);
+            return cos.newStreamCache();
+        }
+    }
+
+    /**
+     * Creates the URL to invoke.
+     *
+     * @param exchange the exchange
+     * @param endpoint the endpoint
+     * @return the URL to invoke
+     */
+    public static String createURL(Exchange exchange, HttpCommonEndpoint endpoint) {
+        String uri = null;
+        if (!(endpoint.isBridgeEndpoint())) {
+            uri = exchange.getIn().getHeader(Exchange.HTTP_URI, String.class);
+        }
+        if (uri == null) {
+            uri = endpoint.getHttpUri().toASCIIString();
+        }
+
+        // resolve placeholders in uri
+        try {
+            uri = exchange.getContext().resolvePropertyPlaceholders(uri);
+        } catch (Exception e) {
+            throw new RuntimeExchangeException("Cannot resolve property placeholders with
uri: " + uri, exchange, e);
+        }
+
+        // append HTTP_PATH to HTTP_URI if it is provided in the header
+        String path = exchange.getIn().getHeader(Exchange.HTTP_PATH, String.class);
+        // NOW the HTTP_PATH is just related path, we don't need to trim it
+        if (path != null) {
+            if (path.startsWith("/")) {
+                path = path.substring(1);
+            }
+            if (path.length() > 0) {
+                // make sure that there is exactly one "/" between HTTP_URI and
+                // HTTP_PATH
+                if (!uri.endsWith("/")) {
+                    uri = uri + "/";
+                }
+                uri = uri.concat(path);
+            }
+        }
+
+        // ensure uri is encoded to be valid
+        uri = UnsafeUriCharactersEncoder.encodeHttpURI(uri);
+
+        return uri;
+    }
+
+    /**
+     * Creates the URI to invoke.
+     *
+     * @param exchange the exchange
+     * @param url      the url to invoke
+     * @param endpoint the endpoint
+     * @return the URI to invoke
+     */
+    public static URI createURI(Exchange exchange, String url, HttpCommonEndpoint endpoint)
throws URISyntaxException {
+        URI uri = new URI(url);
+        // is a query string provided in the endpoint URI or in a header (header overrules
endpoint)
+        String queryString = exchange.getIn().getHeader(Exchange.HTTP_QUERY, String.class);
+        if (queryString == null) {
+            queryString = endpoint.getHttpUri().getRawQuery();
+        }
+        // We should user the query string from the HTTP_URI header
+        if (queryString == null) {
+            queryString = uri.getRawQuery();
+        }
+        if (queryString != null) {
+            // need to encode query string
+            queryString = UnsafeUriCharactersEncoder.encodeHttpURI(queryString);
+            uri = URISupport.createURIWithQuery(uri, queryString);
+        }
+        return uri;
+    }
+
+    /**
+     * Appends the key/value to the headers.
+     * <p/>
+     * This implementation supports keys with multiple values. In such situations the value
+     * will be a {@link java.util.List} that contains the multiple values.
+     *
+     * @param headers  headers
+     * @param key      the key
+     * @param value    the value
+     */
+    @SuppressWarnings("unchecked")
+    public static void appendHeader(Map<String, Object> headers, String key, Object
value) {
+        if (headers.containsKey(key)) {
+            Object existing = headers.get(key);
+            List<Object> list;
+            if (existing instanceof List) {
+                list = (List<Object>) existing;
+            } else {
+                list = new ArrayList<Object>();
+                list.add(existing);
+            }
+            list.add(value);
+            value = list;
+        }
+
+        headers.put(key, value);
+    }
+
+    /**
+     * Extracts the parameter value.
+     * <p/>
+     * This implementation supports HTTP multi value parameters which
+     * is based on the syntax of <tt>[value1, value2, value3]</tt> by returning
+     * a {@link List} containing the values.
+     * <p/>
+     * If the value is not a HTTP mulit value the value is returned as is.
+     *
+     * @param value the parameter value
+     * @return the extracted parameter value, see more details in javadoc.
+     */
+    public static Object extractHttpParameterValue(String value) {
+        if (value == null || ObjectHelper.isEmpty(value)) {
+            return value;
+        }
+
+        // trim value before checking for multiple parameters
+        String trimmed = value.trim();
+
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            // remove the [ ] markers
+            trimmed = trimmed.substring(1, trimmed.length() - 1);
+            List<String> list = new ArrayList<String>();
+            String[] values = trimmed.split(",");
+            for (String s : values) {
+                list.add(s.trim());
+            }
+            return list;
+        }
+
+        return value;
+    }
+
+    /**
+     * Processes any custom {@link org.apache.camel.http.common.UrlRewrite}.
+     *
+     * @param exchange    the exchange
+     * @param url         the url
+     * @param endpoint    the http endpoint
+     * @param producer    the producer
+     * @return            the rewritten url, or <tt>null</tt> to use original
url
+     * @throws Exception is thrown if any error during rewriting url
+     */
+    public static String urlRewrite(Exchange exchange, String url, HttpCommonEndpoint endpoint,
Producer producer) throws Exception {
+        String answer = null;
+
+        String relativeUrl;
+        if (endpoint.getUrlRewrite() != null) {
+            // we should use the relative path if possible
+            String baseUrl;
+            relativeUrl = endpoint.getHttpUri().toASCIIString();
+            if (url.startsWith(relativeUrl)) {
+                baseUrl = url.substring(0, relativeUrl.length());
+                relativeUrl = url.substring(relativeUrl.length());
+            } else {
+                baseUrl = null;
+                relativeUrl = url;
+            }
+            // mark it as null if its empty
+            if (ObjectHelper.isEmpty(relativeUrl)) {
+                relativeUrl = null;
+            }
+
+            String newUrl;
+            if (endpoint.getUrlRewrite() instanceof HttpServletUrlRewrite) {
+                // its servlet based, so we need the servlet request
+                HttpServletRequest request = exchange.getIn().getBody(HttpServletRequest.class);
+                if (request == null) {
+                    HttpMessage msg = exchange.getIn(HttpMessage.class);
+                    if (msg != null) {
+                        request = msg.getRequest();
+                    }
+                }
+                if (request == null) {
+                    throw new IllegalArgumentException("UrlRewrite " + endpoint.getUrlRewrite()
+ " requires the message body to be a"
+                            + "HttpServletRequest instance, but was: " + ObjectHelper.className(exchange.getIn().getBody()));
+                }
+                // we need to adapt the context-path to be the path from the endpoint, if
it came from a http based endpoint
+                // as eg camel-jetty have hardcoded context-path as / for all its servlets/endpoints
+                // we have the actual context-path stored as a header with the key CamelServletContextPath
+                String contextPath = exchange.getIn().getHeader("CamelServletContextPath",
String.class);
+                request = new UrlRewriteHttpServletRequestAdapter(request, contextPath);
+                newUrl = ((HttpServletUrlRewrite) endpoint.getUrlRewrite()).rewrite(url,
relativeUrl, producer, request);
+            } else {
+                newUrl = endpoint.getUrlRewrite().rewrite(url, relativeUrl, producer);
+            }
+
+            if (ObjectHelper.isNotEmpty(newUrl) && !newUrl.equals(url)) {
+                // we got a new url back, that can either be a new absolute url
+                // or a new relative url
+                if (newUrl.startsWith("http:") || newUrl.startsWith("https:")) {
+                    answer = newUrl;
+                } else if (baseUrl != null) {
+                    // avoid double // when adding the urls
+                    if (baseUrl.endsWith("/") && newUrl.startsWith("/")) {
+                        answer = baseUrl + newUrl.substring(1);
+                    } else {
+                        answer = baseUrl + newUrl;
+                    }
+                } else {
+                    // use the new url as is
+                    answer = newUrl;
+                }
+                if (LOG.isDebugEnabled()) {
+                    LOG.debug("Using url rewrite to rewrite from url {} to {} -> {}",
+                            new Object[]{relativeUrl != null ? relativeUrl : url, newUrl,
answer});
+                }
+            }
+        }
+
+        return answer;
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpMessage.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpMessage.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpMessage.java
new file mode 100644
index 0000000..b2f4527
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpMessage.java
@@ -0,0 +1,81 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import java.io.IOException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.impl.DefaultMessage;
+import org.apache.camel.util.ObjectHelper;
+
+/**
+ * @version 
+ */
+public class HttpMessage extends DefaultMessage {
+
+    private HttpServletRequest request;
+    private HttpServletResponse response;
+
+    public HttpMessage(Exchange exchange, HttpServletRequest request, HttpServletResponse
response) {
+        setExchange(exchange);
+        this.request = request;
+        this.response = response;
+        // Put the request and response into the message header
+        this.setHeader(Exchange.HTTP_SERVLET_REQUEST, request);
+        this.setHeader(Exchange.HTTP_SERVLET_RESPONSE, response);
+        
+        // Check the setting of exchange
+        Boolean flag = exchange.getProperty(Exchange.SKIP_WWW_FORM_URLENCODED, Boolean.class);
+        if (flag != null && flag) {
+            this.setHeader(Exchange.SKIP_WWW_FORM_URLENCODED, Boolean.TRUE);
+        }
+
+        // use binding to read the request allowing end users to use their
+        // implementation of the binding
+        getEndpoint().getBinding().readRequest(request, this);
+    }
+
+    public HttpServletRequest getRequest() {
+        return request;
+    }
+
+    public HttpServletResponse getResponse() {
+        return response;
+    }
+
+    @Override
+    protected Object createBody() {
+        try {
+            return getEndpoint().getBinding().parseBody(this);
+        } catch (IOException e) {
+            throw new RuntimeCamelException(e);
+        }
+    }
+    
+    private HttpCommonEndpoint getEndpoint() {
+        return (HttpCommonEndpoint) getExchange().getFromEndpoint();
+    }
+
+    @Override
+    public String toString() {
+        // do not use toString on HTTP message
+        return "HttpMessage@" + ObjectHelper.getIdentityHashCode(this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpOperationFailedException.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpOperationFailedException.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpOperationFailedException.java
new file mode 100644
index 0000000..2008658
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpOperationFailedException.java
@@ -0,0 +1,75 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import java.util.Map;
+
+import org.apache.camel.CamelException;
+import org.apache.camel.util.ObjectHelper;
+
+public class HttpOperationFailedException extends CamelException {
+    private static final long serialVersionUID = -8721487434390572634L;
+    private final String uri;
+    private final String redirectLocation;
+    private final int statusCode;
+    private final String statusText;
+    private final Map<String, String> responseHeaders;
+    private final String responseBody;
+
+    public HttpOperationFailedException(String uri, int statusCode, String statusText, String
location, Map<String, String> responseHeaders, String responseBody) {
+        super("HTTP operation failed invoking " + uri + " with statusCode: " + statusCode
+ (location != null ? ", redirectLocation: " + location : ""));
+        this.uri = uri;
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+        this.redirectLocation = location;
+        this.responseHeaders = responseHeaders;
+        this.responseBody = responseBody;
+    }
+
+    public String getUri() {
+        return uri;
+    }
+
+    public boolean isRedirectError() {
+        return statusCode >= 300 && statusCode < 400;
+    }
+
+    public boolean hasRedirectLocation() {
+        return ObjectHelper.isNotEmpty(redirectLocation);
+    }
+
+    public String getRedirectLocation() {
+        return redirectLocation;
+    }
+
+    public int getStatusCode() {
+        return statusCode;
+    }
+
+    public String getStatusText() {
+        return statusText;
+    }
+
+    public Map<String, String> getResponseHeaders() {
+        return responseHeaders;
+    }
+
+    public String getResponseBody() {
+        return responseBody;
+    }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpProtocolHeaderFilterStrategy.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpProtocolHeaderFilterStrategy.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpProtocolHeaderFilterStrategy.java
new file mode 100644
index 0000000..bf09881
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpProtocolHeaderFilterStrategy.java
@@ -0,0 +1,87 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import org.apache.camel.impl.DefaultHeaderFilterStrategy;
+
+public class HttpProtocolHeaderFilterStrategy extends DefaultHeaderFilterStrategy {
+    
+    public HttpProtocolHeaderFilterStrategy() {
+        initialize();  
+    }
+
+    // Just add the http headers here 
+    protected void initialize() {
+        getInFilter().add("host");
+        
+        getInFilter().add("content-encoding");
+        getInFilter().add("content-language");
+        getInFilter().add("content-location");
+        getInFilter().add("content-md5");
+        getInFilter().add("content-length");
+        getInFilter().add("content-type");
+        getInFilter().add("content-range");
+        
+        getInFilter().add("dav");
+        getInFilter().add("depth");
+        getInFilter().add("destination");
+        getInFilter().add("etag");
+        getInFilter().add("expect");
+        getInFilter().add("expires");
+        getInFilter().add("from");
+        getInFilter().add("if");
+        getInFilter().add("if-match");
+        getInFilter().add("if-modified-since");
+        getInFilter().add("if-none-match");
+        getInFilter().add("if-range");
+        getInFilter().add("if-unmodified-since");
+        getInFilter().add("last-modified");
+        getInFilter().add("location");
+        getInFilter().add("lock-token");
+        getInFilter().add("max-forwards");
+        getInFilter().add("overwrite");
+        getInFilter().add("pragma");
+        getInFilter().add("proxy-authenticate");
+        getInFilter().add("proxy-authorization");
+        getInFilter().add("range");
+        getInFilter().add("referer");
+        getInFilter().add("retry-after");
+        getInFilter().add("server");
+        getInFilter().add("status-uri");
+        getInFilter().add("te");
+        getInFilter().add("timeout");
+      
+        getInFilter().add("user-agent");
+        getInFilter().add("vary");
+  
+        getInFilter().add("www-authenticate");
+        
+        // Add the filter for the Generic Message header
+        // http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.5
+        getInFilter().add("cache-control");
+        getInFilter().add("connection");
+        getInFilter().add("date");
+        getInFilter().add("pragma");
+        getInFilter().add("trailer");
+        getInFilter().add("transfer-encoding");
+        getInFilter().add("upgrade");
+        getInFilter().add("via");
+        getInFilter().add("warning");
+               
+        setLowerCase(true);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletResolveConsumerStrategy.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletResolveConsumerStrategy.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletResolveConsumerStrategy.java
new file mode 100644
index 0000000..a48f4b6
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletResolveConsumerStrategy.java
@@ -0,0 +1,50 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * A default implementation of {@link org.apache.camel.http.common.ServletResolveConsumerStrategy}.
+ */
+public class HttpServletResolveConsumerStrategy implements ServletResolveConsumerStrategy
{
+
+    @Override
+    public HttpConsumer resolve(HttpServletRequest request, Map<String, HttpConsumer>
consumers) {
+        String path = request.getPathInfo();
+        if (path == null) {
+            return null;
+        }
+        HttpConsumer answer = consumers.get(path);
+
+        if (answer == null) {
+            for (String key : consumers.keySet()) {
+                //We need to look up the consumer path here
+                String consumerPath = consumers.get(key).getPath();
+                HttpConsumer consumer = consumers.get(key);
+                // Just make sure the we get the right consumer path first
+                if (consumerPath.equals(path) || (consumer.getEndpoint().isMatchOnUriPrefix()
&& path.startsWith(consumerPath))) {
+                    answer = consumers.get(key);
+                    break;
+                }
+            }
+        }
+        return answer;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletUrlRewrite.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletUrlRewrite.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletUrlRewrite.java
new file mode 100644
index 0000000..f6db8f1
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/HttpServletUrlRewrite.java
@@ -0,0 +1,45 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.camel.Producer;
+
+/**
+ * Extended {@link UrlRewrite} which leverages {@link HttpServletRequest}
+ * during the rewrite process.
+ * <p/>
+ * For example the camel-urlrewrite component supports
+ * {@link HttpServletUrlRewrite} implementations.
+ */
+public interface HttpServletUrlRewrite extends UrlRewrite {
+
+    /**
+     * Rewrite the url.
+     *
+     * @param url  the absolute url (eg with scheme://host:port/path?query)
+     * @param relativeUrl optional relative url, if bridging endpoints, which then would
be without the base path from the
+     *                    endpoint from the given producer.
+     * @param producer the producer to use the rewritten url
+     * @param request  the http servlet request
+     * @return the rewritten url, or <tt>null</tt> to use the original url
+     * @throws Exception is thrown if error rewriting the url
+     */
+    String rewrite(String url, String relativeUrl, Producer producer, HttpServletRequest
request) throws Exception;
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/ServletResolveConsumerStrategy.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/ServletResolveConsumerStrategy.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/ServletResolveConsumerStrategy.java
new file mode 100644
index 0000000..a16df19
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/ServletResolveConsumerStrategy.java
@@ -0,0 +1,37 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * Strategy to resolve which consumer to service an incoming {@link javax.servlet.http.HttpServletRequest}.
+ */
+public interface ServletResolveConsumerStrategy {
+
+    /**
+     * Resolve the consumer to use.
+     *
+     * @param request   the http request
+     * @param consumers the map of registered consumers
+     * @return the consumer to service the request, or <tt>null</tt> if no match,
+     * which sends back a {@link javax.servlet.http.HttpServletResponse#SC_NOT_FOUND} to
the client.
+     */
+    HttpConsumer resolve(HttpServletRequest request, Map<String, HttpConsumer> consumers);
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewrite.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewrite.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewrite.java
new file mode 100644
index 0000000..1c44624
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewrite.java
@@ -0,0 +1,41 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import org.apache.camel.Producer;
+
+/**
+ * Allows to plugin custom strategy for rewriting url.
+ * <p/>
+ * This allows for example to proxy http services and plugin a url rewrite
+ * strategy such as the <a href="http://camel.apache.org/urlrewrite">url-rewrite</a>
component.
+ */
+public interface UrlRewrite {
+
+    /**
+     * Rewrite the url.
+     *
+     * @param url  the absolute url (eg with scheme://host:port/path?query)
+     * @param relativeUrl optional relative url, if bridging endpoints, which then would
be without the base path from the
+     *                    endpoint from the given producer.
+     * @param producer the producer to use the rewritten url
+     * @return the rewritten url, or <tt>null</tt> to use the original url
+     * @throws Exception is thrown if error rewriting the url
+     */
+    String rewrite(String url, String relativeUrl, Producer producer) throws Exception;
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/e51b7f8d/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewriteHttpServletRequestAdapter.java
----------------------------------------------------------------------
diff --git a/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewriteHttpServletRequestAdapter.java
b/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewriteHttpServletRequestAdapter.java
new file mode 100644
index 0000000..78b7b11
--- /dev/null
+++ b/components/camel-http-common/src/main/java/org/apache/camel/http/common/UrlRewriteHttpServletRequestAdapter.java
@@ -0,0 +1,49 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.http.common;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+
+/**
+ * Special adapter when {@link org.apache.camel.http.common.HttpServletUrlRewrite} is in
use,
+ * and the route started from came-jetty/camel-serlvet.
+ * <p/>
+ * This adapter ensures that we can control the context-path returned from the
+ * {@link javax.servlet.http.HttpServletRequest#getContextPath()} method.
+ * This allows us to ensure the context-path is based on the endpoint path, as the
+ * camel-jetty/camel-servlet server implementation uses the root ("/") context-path
+ * for all the servlets/endpoints.
+ */
+public final class UrlRewriteHttpServletRequestAdapter extends HttpServletRequestWrapper
{
+
+    private final String contextPath;
+
+    /**
+     * Creates this adapter
+     * @param delegate    the real http servlet request to delegate.
+     * @param contextPath use to override and return this context-path
+     */
+    public UrlRewriteHttpServletRequestAdapter(HttpServletRequest delegate, String contextPath)
{
+        super(delegate);
+        this.contextPath = contextPath;
+    }
+
+    public String getContextPath() {
+        return contextPath != null ? contextPath : super.getContextPath();
+    }
+}


Mime
View raw message