Merge branch 'master' of ssh://git.eclipse.org/gitroot/jetty/org.eclipse.jetty.project

jetty-client/src/test/java/org/eclipse/jetty/client/AsyncSslHttpExchangeTest.java

@@ -29,4 +29,12 @@ public class AsyncSslHttpExchangeTest extends SslHttpExchangeTest
         _httpClient = serverAndClientCreator.createClient(3000L,3500L,2000);
         _port = _server.getConnectors()[0].getLocalPort();
     }
+
+    @Override
+    public void testPerf() throws Exception
+    {
+        super.testPerf();
+    }
+    
+    
 }

jetty-rewrite/pom.xml

@@ -74,6 +74,11 @@
       <artifactId>jetty-server</artifactId>
       <version>${project.version}</version>
     </dependency>
+    <dependency>
+      <groupId>org.eclipse.jetty</groupId>
+      <artifactId>jetty-client</artifactId>
+      <version>${project.version}</version>
+    </dependency>
     <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>servlet-api</artifactId>

jetty-rewrite/src/main/java/org/eclipse/jetty/rewrite/handler/ProxyRule.java

@@ -0,0 +1,487 @@
+package org.eclipse.jetty.rewrite.handler;
+
+//========================================================================
+//Copyright (c) 2006-2009 Mort Bay Consulting Pty. Ltd.
+//------------------------------------------------------------------------
+//All rights reserved. This program and the accompanying materials
+//are made available under the terms of the Eclipse Public License v1.0
+//and Apache License v2.0 which accompanies this distribution.
+//The Eclipse Public License is available at
+//http://www.eclipse.org/legal/epl-v10.html
+//The Apache License v2.0 is available at
+//http://www.opensource.org/licenses/apache2.0.php
+//You may elect to redistribute this code under either of these licenses.
+//========================================================================
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.util.Enumeration;
+import java.util.HashSet;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.HttpExchange;
+import org.eclipse.jetty.http.HttpHeaderValues;
+import org.eclipse.jetty.http.HttpHeaders;
+import org.eclipse.jetty.http.HttpURI;
+import org.eclipse.jetty.http.PathMap;
+import org.eclipse.jetty.io.Buffer;
+import org.eclipse.jetty.io.EofException;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+
+/**
+ * This rule allows the user to configure a particular rewrite rule that will proxy out
+ * to a configured location.  This rule uses the jetty http client.
+ * 
+ * Rule rule = new ProxyRule();
+ * rule.setPattern("/foo/*");
+ * rule.setProxyTo("http://url.com");
+ * 
+ * see api for other configuration options which influence the configuration of the jetty 
+ * client instance
+ * 
+ */
+public class ProxyRule extends PatternRule
+{
+    private static final Logger _log = Log.getLogger(ProxyRule.class);
+
+    private HttpClient _client;
+    private String _hostHeader;
+    private String _proxyTo;
+    
+    private int _connectorType = 2;
+    private String _maxThreads;
+    private String _maxConnections;
+    private String _timeout;
+    private String _idleTimeout;
+    private String _requestHeaderSize;
+    private String _requestBufferSize;
+    private String _responseHeaderSize;
+    private String _responseBufferSize;
+
+    private HashSet<String> _DontProxyHeaders = new HashSet<String>();
+    {
+        _DontProxyHeaders.add("proxy-connection");
+        _DontProxyHeaders.add("connection");
+        _DontProxyHeaders.add("keep-alive");
+        _DontProxyHeaders.add("transfer-encoding");
+        _DontProxyHeaders.add("te");
+        _DontProxyHeaders.add("trailer");
+        _DontProxyHeaders.add("proxy-authorization");
+        _DontProxyHeaders.add("proxy-authenticate");
+        _DontProxyHeaders.add("upgrade");
+    }
+
+    /* ------------------------------------------------------------ */
+    public ProxyRule()
+    {
+        _handling = true;
+        _terminating = true;
+    }
+
+    /* ------------------------------------------------------------ */
+    private void initializeClient() throws Exception
+    {
+        _client = new HttpClient();
+        _client.setConnectorType(_connectorType);
+        
+        if ( _maxThreads != null )
+        {
+            _client.setThreadPool(new QueuedThreadPool(Integer.parseInt(_maxThreads)));
+        }
+        else
+        {
+            _client.setThreadPool(new QueuedThreadPool());
+        }
+        
+        if ( _maxConnections != null )
+        {
+            _client.setMaxConnectionsPerAddress(Integer.parseInt(_maxConnections));
+        }
+        
+        if ( _timeout != null )
+        {
+            _client.setTimeout(Long.parseLong(_timeout));
+        }
+        
+        if ( _idleTimeout != null )
+        {
+            _client.setIdleTimeout(Long.parseLong(_idleTimeout));
+        }
+        
+        if ( _requestBufferSize != null )
+        {
+            _client.setRequestBufferSize(Integer.parseInt(_requestBufferSize));
+        }
+        
+        if ( _requestHeaderSize != null )
+        {
+            _client.setRequestHeaderSize(Integer.parseInt(_requestHeaderSize));
+        }
+        
+        if ( _responseBufferSize != null )
+        {
+            _client.setResponseBufferSize(Integer.parseInt(_responseBufferSize));
+        }
+        
+        if ( _responseHeaderSize != null )
+        {
+            _client.setResponseHeaderSize(Integer.parseInt(_responseHeaderSize));
+        }                 
+        
+        _client.start();
+    }
+
+    /* ------------------------------------------------------------ */
+    private HttpURI proxyHttpURI(String uri) throws MalformedURLException
+    {
+        return new HttpURI(_proxyTo + uri);
+    }
+
+    /* ------------------------------------------------------------ */
+    @Override
+    protected String apply(String target, HttpServletRequest request, final HttpServletResponse response) throws IOException
+    {
+        synchronized (this)
+        {
+            if (_client == null)
+            {
+                try
+                {
+                    initializeClient();
+                }
+                catch (Exception e)
+                {
+                    throw new IOException("Unable to proxy: " + e.getMessage());
+                }
+            }
+        }
+
+        final int debug = _log.isDebugEnabled()?request.hashCode():0;
+
+        final InputStream in = request.getInputStream();
+        final OutputStream out = response.getOutputStream();
+
+        HttpURI url = createUrl(request,debug);
+
+        if (url == null)
+        {
+            response.sendError(HttpServletResponse.SC_FORBIDDEN);
+            return target;
+        }
+
+        HttpExchange exchange = new HttpExchange()
+        {
+            @Override
+            protected void onRequestCommitted() throws IOException
+            {
+            }
+
+            @Override
+            protected void onRequestComplete() throws IOException
+            {
+            }
+
+            @Override
+            protected void onResponseComplete() throws IOException
+            {
+                if (debug != 0)
+                    _log.debug(debug + " complete");
+            }
+
+            @Override
+            protected void onResponseContent(Buffer content) throws IOException
+            {
+                if (debug != 0)
+                    _log.debug(debug + " content" + content.length());
+                content.writeTo(out);
+            }
+
+            @Override
+            protected void onResponseHeaderComplete() throws IOException
+            {
+            }
+
+            @SuppressWarnings("deprecation")
+            @Override
+            protected void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException
+            {
+                if (debug != 0)
+                    _log.debug(debug + " " + version + " " + status + " " + reason);
+
+                if (reason != null && reason.length() > 0)
+                    response.setStatus(status,reason.toString());
+                else
+                    response.setStatus(status);
+            }
+
+            @Override
+            protected void onResponseHeader(Buffer name, Buffer value) throws IOException
+            {
+                String s = name.toString().toLowerCase();
+                if (!_DontProxyHeaders.contains(s) || (HttpHeaders.CONNECTION_BUFFER.equals(name) && HttpHeaderValues.CLOSE_BUFFER.equals(value)))
+                {
+                    if (debug != 0)
+                        _log.debug(debug + " " + name + ": " + value);
+
+                    response.addHeader(name.toString(),value.toString());
+                }
+                else if (debug != 0)
+                    _log.debug(debug + " " + name + "! " + value);
+            }
+
+            @Override
+            protected void onConnectionFailed(Throwable ex)
+            {
+                _log.warn(ex.toString());
+                _log.debug(ex);
+                if (!response.isCommitted())
+                {
+                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+                }
+            }
+
+            @Override
+            protected void onException(Throwable ex)
+            {
+                if (ex instanceof EofException)
+                {
+                    _log.ignore(ex);
+                    return;
+                }
+                _log.warn(ex.toString());
+                _log.debug(ex);
+                if (!response.isCommitted())
+                {
+                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+                }
+            }
+
+            @Override
+            protected void onExpire()
+            {
+                if (!response.isCommitted())
+                {
+                    response.setStatus(HttpServletResponse.SC_GATEWAY_TIMEOUT);
+                }
+            }
+
+        };
+
+        exchange.setMethod(request.getMethod());
+        exchange.setURL(url.toString());
+        exchange.setVersion(request.getProtocol());
+
+        if (debug != 0)
+        {
+            _log.debug(debug + " " + request.getMethod() + " " + url + " " + request.getProtocol());
+        }
+        
+        boolean hasContent = createHeaders(request,debug,exchange);
+
+        if (hasContent)
+        {
+            exchange.setRequestContentSource(in);
+        }
+        
+        /*
+         * we need to set the timeout on the exchange to take into account the timeout of the HttpClient and the HttpExchange
+         */
+        long ctimeout = (_client.getTimeout() > exchange.getTimeout())?_client.getTimeout():exchange.getTimeout();
+        exchange.setTimeout(ctimeout);
+
+        _client.send(exchange);
+        
+        try
+        {
+            exchange.waitForDone();
+        }
+        catch (InterruptedException e)
+        {
+            _log.info("Exception while waiting for response on proxied request", e);
+        }
+        return target;
+    }
+
+    /* ------------------------------------------------------------ */
+    private HttpURI createUrl(HttpServletRequest request, final int debug) throws MalformedURLException
+    {
+        String uri = request.getRequestURI();
+        
+        if (request.getQueryString() != null)
+        {
+            uri += "?" + request.getQueryString();
+        }
+        
+        uri = PathMap.pathInfo(_pattern,uri);
+        
+        if(uri==null)
+        {
+            uri = "/";
+        }
+        
+        HttpURI url = proxyHttpURI(uri);
+
+        if (debug != 0)
+        {
+            _log.debug(debug + " proxy " + uri + "-->" + url);
+        }
+        
+        return url;
+    }
+
+    /* ------------------------------------------------------------ */
+    private boolean createHeaders(final HttpServletRequest request, final int debug, HttpExchange exchange)
+    {
+        // check connection header
+        String connectionHdr = request.getHeader("Connection");
+        if (connectionHdr != null)
+        {
+            connectionHdr = connectionHdr.toLowerCase();
+            if (connectionHdr.indexOf("keep-alive") < 0 && connectionHdr.indexOf("close") < 0)
+            {
+                connectionHdr = null;
+            }
+        }
+
+        // force host
+        if (_hostHeader != null)
+        {
+            exchange.setRequestHeader("Host",_hostHeader);
+        }
+
+        // copy headers
+        boolean xForwardedFor = false;
+        boolean hasContent = false;
+        long contentLength = -1;
+        Enumeration<?> enm = request.getHeaderNames();
+        while (enm.hasMoreElements())
+        {
+            // TODO could be better than this!
+            String hdr = (String)enm.nextElement();
+            String lhdr = hdr.toLowerCase();
+
+            if (_DontProxyHeaders.contains(lhdr))
+                continue;
+            if (connectionHdr != null && connectionHdr.indexOf(lhdr) >= 0)
+                continue;
+            if (_hostHeader != null && "host".equals(lhdr))
+                continue;
+
+            if ("content-type".equals(lhdr))
+                hasContent = true;
+            else if ("content-length".equals(lhdr))
+            {
+                contentLength = request.getContentLength();
+                exchange.setRequestHeader(HttpHeaders.CONTENT_LENGTH,Long.toString(contentLength));
+                if (contentLength > 0)
+                    hasContent = true;
+            }
+            else if ("x-forwarded-for".equals(lhdr))
+                xForwardedFor = true;
+
+            Enumeration<?> vals = request.getHeaders(hdr);
+            while (vals.hasMoreElements())
+            {
+                String val = (String)vals.nextElement();
+                if (val != null)
+                {
+                    if (debug != 0)
+                        _log.debug(debug + " " + hdr + ": " + val);
+
+                    exchange.setRequestHeader(hdr,val);
+                }
+            }
+        }
+
+        // Proxy headers
+        exchange.setRequestHeader("Via","1.1 (jetty)");
+        if (!xForwardedFor)
+        {
+            exchange.addRequestHeader("X-Forwarded-For",request.getRemoteAddr());
+            exchange.addRequestHeader("X-Forwarded-Proto",request.getScheme());
+            exchange.addRequestHeader("X-Forwarded-Host",request.getServerName());
+            exchange.addRequestHeader("X-Forwarded-Server",request.getLocalName());
+        }
+        return hasContent;
+    }
+
+    /* ------------------------------------------------------------ */
+    public void setProxyTo(String proxyTo)
+    {
+        this._proxyTo = proxyTo;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setMaxThreads(String maxThreads)
+    {
+        this._maxThreads = maxThreads;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setMaxConnections(String maxConnections)
+    {
+        _maxConnections = maxConnections;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setTimeout(String timeout)
+    {
+        _timeout = timeout;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setIdleTimeout(String idleTimeout)
+    {
+        _idleTimeout = idleTimeout;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setRequestHeaderSize(String requestHeaderSize)
+    {
+        _requestHeaderSize = requestHeaderSize;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setRequestBufferSize(String requestBufferSize)
+    {
+        _requestBufferSize = requestBufferSize;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setResponseHeaderSize(String responseHeaderSize)
+    {
+        _responseHeaderSize = responseHeaderSize;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void setResponseBufferSize(String responseBufferSize)
+    {
+        _responseBufferSize = responseBufferSize;
+    }
+    
+    /* ------------------------------------------------------------ */
+    public void addDontProxyHeaders(String dontProxyHeader)
+    {
+        _DontProxyHeaders.add(dontProxyHeader);
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     *   CONNECTOR_SOCKET = 0;
+     *   CONNECTOR_SELECT_CHANNEL = 2; (default)
+     * 
+     * @param connectorType
+     */
+    public void setConnectorType( int connectorType )
+    {
+        _connectorType = connectorType;
+    }
+    
+}

jetty-rewrite/src/main/java/org/eclipse/jetty/rewrite/handler/RewriteHandler.java

@@ -19,7 +19,6 @@ import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
-import org.eclipse.jetty.http.PathMap;
 import org.eclipse.jetty.server.Request;
 import org.eclipse.jetty.server.handler.HandlerWrapper;
 
@@ -46,6 +45,7 @@ import org.eclipse.jetty.server.handler.HandlerWrapper;
  * <li> {@link ResponsePatternRule} - sets the status/error codes. </li>
  * <li> {@link RewritePatternRule} - rewrites the requested URI. </li>
  * <li> {@link RewriteRegexRule} - rewrites the requested URI using regular expression for pattern matching. </li>
+ * <li> {@link ProxyRule} - proxies the requested URI to the host defined in proxyTo. </li>
  * <li> {@link MsieSslRule} - disables the keep alive on SSL for IE5 and IE6. </li>
  * <li> {@link LegacyRule} - the old version of rewrite. </li>
  * <li> {@link ForwardedSchemeHeaderRule} - set the scheme according to the headers present. </li>
@@ -68,6 +68,13 @@ import org.eclipse.jetty.server.handler.HandlerWrapper;
  *           &lt;/Item&gt;
  *
  *           &lt;Item&gt;
+ *             &lt;New id="rewrite" class="org.eclipse.jetty.rewrite.handler.ProxyRule"&gt;
+ *               &lt;Set name="pattern"&gt;/*&lt;/Set&gt;
+ *               &lt;Set name="proxyTo"&gt;http://webtide.com:8080&lt;/Set&gt;
+ *             &lt;/New&gt;
+ *           &lt;/Item&gt;
+ *
+ *           &lt;Item&gt;
  *             &lt;New id="response" class="org.eclipse.jetty.rewrite.handler.ResponsePatternRule"&gt;
  *               &lt;Set name="pattern"&gt;/session/&lt;/Set&gt;
  *               &lt;Set name="code"&gt;400&lt;/Set&gt;

jetty-rewrite/src/test/java/org/eclipse/jetty/rewrite/handler/ProxyRuleTest.java

@@ -0,0 +1,132 @@
+package org.eclipse.jetty.rewrite.handler;
+
+//========================================================================
+//Copyright (c) 2006-2009 Mort Bay Consulting Pty. Ltd.
+//------------------------------------------------------------------------
+//All rights reserved. This program and the accompanying materials
+//are made available under the terms of the Eclipse Public License v1.0
+//and Apache License v2.0 which accompanies this distribution.
+//The Eclipse Public License is available at
+//http://www.eclipse.org/legal/epl-v10.html
+//The Apache License v2.0 is available at
+//http://www.opensource.org/licenses/apache2.0.php
+//You may elect to redistribute this code under either of these licenses.
+//========================================================================
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.ContentExchange;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.HttpExchange;
+import org.eclipse.jetty.http.HttpMethods;
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.eclipse.jetty.server.nio.SelectChannelConnector;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class ProxyRuleTest
+{
+    private static ProxyRule _rule;
+    private static RewriteHandler _handler;
+    private static Server _proxyServer = new Server();
+    private static Connector _proxyServerConnector = new SelectChannelConnector();
+    private static Server _targetServer = new Server();
+    private static Connector _targetServerConnector = new SelectChannelConnector();
+    private static HttpClient _httpClient = new HttpClient();
+
+    @BeforeClass
+    public static void setupOnce() throws Exception
+    {
+        _targetServer.addConnector(_targetServerConnector);
+        _targetServer.setHandler(new AbstractHandler()
+        {
+            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+            {
+                baseRequest.setHandled(true);
+                String responseString = "uri: " + request.getRequestURI() + " some content";
+                response.getOutputStream().write(responseString.getBytes());
+                response.setStatus(201);
+            }
+        });
+        _targetServer.start();
+
+        _rule = new ProxyRule();
+        _rule.setPattern("/foo/*");
+        _rule.setProxyTo("http://localhost:" + _targetServerConnector.getLocalPort());
+        _handler = new RewriteHandler();
+        _handler.setRewriteRequestURI(true);
+        _handler.setRules(new Rule[] { _rule });
+
+        _proxyServer.addConnector(_proxyServerConnector);
+        _proxyServer.setHandler(_handler);
+        _proxyServer.start();
+
+        _httpClient.start();
+    }
+
+    @AfterClass
+    public static void destroy() throws Exception
+    {
+        _httpClient.stop();
+        _proxyServer.stop();
+        _targetServer.stop();
+        _rule = null;
+    }
+
+    @Test
+    public void testProxy() throws Exception
+    {
+
+        ContentExchange exchange = new ContentExchange(true);
+        exchange.setMethod(HttpMethods.GET);
+        String body = "BODY";
+        String url = "http://localhost:" + _proxyServerConnector.getLocalPort() + "/foo?body=" + URLEncoder.encode(body,"UTF-8");
+        exchange.setURL(url);
+
+        _httpClient.send(exchange);
+        assertEquals(HttpExchange.STATUS_COMPLETED,exchange.waitForDone());
+        assertEquals("uri: / some content",exchange.getResponseContent());
+        assertEquals(201,exchange.getResponseStatus());
+    }
+
+    @Test
+    public void testProxyWithDeeperPath() throws Exception
+    {
+
+        ContentExchange exchange = new ContentExchange(true);
+        exchange.setMethod(HttpMethods.GET);
+        String body = "BODY";
+        String url = "http://localhost:" + _proxyServerConnector.getLocalPort() + "/foo/bar/foobar?body=" + URLEncoder.encode(body,"UTF-8");
+        exchange.setURL(url);
+
+        _httpClient.send(exchange);
+        assertEquals(HttpExchange.STATUS_COMPLETED,exchange.waitForDone());
+        assertEquals("uri: /bar/foobar some content",exchange.getResponseContent());
+        assertEquals(201,exchange.getResponseStatus());
+    }
+
+    @Test
+    public void testProxyNoMatch() throws Exception
+    {
+        ContentExchange exchange = new ContentExchange(true);
+        exchange.setMethod(HttpMethods.GET);
+        String body = "BODY";
+        String url = "http://localhost:" + _proxyServerConnector.getLocalPort() + "/foobar?body=" + URLEncoder.encode(body,"UTF-8");
+        exchange.setURL(url);
+
+        _httpClient.send(exchange);
+        assertEquals(HttpExchange.STATUS_COMPLETED,exchange.waitForDone());
+        assertEquals(404,exchange.getResponseStatus());
+    }
+}

jetty-server/src/main/java/org/eclipse/jetty/server/ssl/SslSelectChannelConnector.java

@@ -99,8 +99,6 @@ public class SslSelectChannelConnector extends SelectChannelConnector implements
         SSLEngine sslEngine=sslHttpChannelEndpoint.getSSLEngine();
         SSLSession sslSession=sslEngine.getSession();
                 
-        System.err.println(sslSession.getProtocol());
-        
         SslCertificates.customize(sslSession,endpoint,request);
     }
 

pom.xml

@@ -185,7 +185,7 @@
         <plugin>
           <groupId>org.eclipse.jetty.toolchain</groupId>
           <artifactId>jetty-version-maven-plugin</artifactId>
-          <version>1.0.3</version>
+          <version>1.0.6</version>
         </plugin>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>