merge from master

.gitignore

@@ -34,3 +34,6 @@ target/
 
 # merge tooling
 *.orig
+
+#maven
+*.versionsBackup

example-jetty-embedded/src/main/java/org/eclipse/jetty/embedded/DumpServlet.java

@@ -0,0 +1,44 @@
+// ========================================================================
+// Copyright (c) 2009-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. 
+// ========================================================================
+
+
+package org.eclipse.jetty.embedded;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@SuppressWarnings("serial")
+public class DumpServlet extends HttpServlet
+{
+    public DumpServlet()
+    {
+    }
+
+    @Override
+    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
+    {
+        response.setContentType("text/html");
+        response.setStatus(HttpServletResponse.SC_OK);
+        response.getWriter().println("<h1>DumpServlet</h1><pre>");
+        response.getWriter().println("requestURI=" + request.getRequestURI());
+        response.getWriter().println("contextPath=" + request.getContextPath());
+        response.getWriter().println("servletPath=" + request.getServletPath());
+        response.getWriter().println("pathInfo=" + request.getPathInfo());
+        response.getWriter().println("session=" + request.getSession(true).getId());
+        response.getWriter().println("</pre>");
+    }
+}

example-jetty-embedded/src/main/java/org/eclipse/jetty/embedded/HelloServlet.java

@@ -40,7 +40,6 @@ public class HelloServlet extends HttpServlet
     {
         response.setContentType("text/html");
         response.setStatus(HttpServletResponse.SC_OK);
-        response.getWriter().println("<h1>" + greeting + " SimpleServlet</h1>");
+        response.getWriter().println("<h1>" + greeting + " from HelloServlet</h1>");
-        response.getWriter().println("session=" + request.getSession(true).getId());
     }
 }

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

@@ -0,0 +1,149 @@
+package org.eclipse.jetty.rewrite.handler;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.handler.ContextHandler;
+import org.eclipse.jetty.server.handler.ContextHandler.Context;
+import org.eclipse.jetty.server.handler.ScopedHandler;
+import org.eclipse.jetty.util.component.AggregateLifeCycle;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+
+
+/* ------------------------------------------------------------ */
+/** A handle that uses regular expressions to select the target.
+ * <p>
+ * This handler applies a list of regex to target name mappings to the URIs of requests. 
+ * If the regex matches the URI, then the mapped target name is used in the nested
+ * call to {@link #doScope(String, Request, HttpServletRequest, HttpServletResponse)}.
+ * <p>
+ * This handler should be installed as the first handler in a Context.   It can be configured
+ * either with direct calls to {@link #addPatternTarget(String, String)} or by setting
+ * the context init parameters "org.eclipse.jetty.rewrite.handler.REGEX_MAPPINGS" to a comma
+ * separated list of strings in the format regex==target.
+ */
+public class RegexTargetHandler extends ScopedHandler
+{
+    private final static Logger LOG = Log.getLogger(RegexTargetHandler.class);
+    public final static String REGEX_MAPPINGS="org.eclipse.jetty.rewrite.handler.REGEX_MAPPINGS";
+    static class RegexMapping
+    {
+        RegexMapping(String regex,String target)
+        {
+            _pattern=Pattern.compile(regex);
+            _target=target;
+        }
+        final Pattern _pattern;
+        final String _target;
+        
+        public String toString()
+        {
+            return _pattern+"=="+_target;
+        }
+    }
+    
+    final private List<RegexTargetHandler.RegexMapping> _patterns = new CopyOnWriteArrayList<RegexTargetHandler.RegexMapping>();
+    
+    /* ------------------------------------------------------------ */
+    /** Add a pattern to target mapping.
+     * @param pattern The regular expression pattern to match.  
+     * @param target The target (normally servlet name) to handle the request
+     */
+    public void addPatternTarget(String pattern,String target)
+    {
+        _patterns.add(new RegexMapping(pattern,target));
+    }
+
+    /* ------------------------------------------------------------ */
+    @Override
+    protected void doStart() throws Exception
+    {
+        super.doStart();
+        
+        Context context = ContextHandler.getCurrentContext();
+        if (context!=null)
+        {
+            String config=context.getInitParameter(REGEX_MAPPINGS);
+            LOG.debug("{}={}",REGEX_MAPPINGS,config);
+            String[] mappings=config.split("\\s*,\\s*");
+            for (String mapping : mappings)
+            {
+                mapping=mapping.trim();
+                String[] parts=mapping.split("\\s*==\\s*");
+                if (parts.length==2)
+                {
+                    String pattern=parts[0];
+                    String target=parts[1];
+                    addPatternTarget(pattern,target);
+                }
+                else
+                    LOG.warn("Bad regex mapping: "+mapping);
+            }
+        }
+    }
+
+    /* ------------------------------------------------------------ */
+    @Override
+    public void doScope(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+    {
+        for (RegexTargetHandler.RegexMapping rm : _patterns)
+        {
+            Matcher m=rm._pattern.matcher(target);
+            if (m.matches())
+            {
+                String new_target = rm._target;
+                final String sp;
+                final String pi;
+                
+                if (m.groupCount()==1&&target.endsWith(m.group(1)))
+                {
+                    pi=m.group(1);
+                    sp=target.substring(0,target.length()-pi.length());
+                }
+                else
+                {
+                    sp=target;
+                    pi=null;
+                }
+                baseRequest.setServletPath(sp);
+                baseRequest.setPathInfo(pi);
+                baseRequest.setAttribute("org.eclipse.jetty.servlet.REGEX_PATH",target);
+                super.nextScope(new_target,baseRequest,request,response);
+                return;
+            }
+        }
+        super.nextScope(target,baseRequest,request,response);
+    }
+
+    /* ------------------------------------------------------------ */
+    @Override
+    public void doHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+    {
+        String path=(String)baseRequest.getAttribute("org.eclipse.jetty.servlet.REGEX_PATH");
+        if (path==null)
+            path=target;
+        else
+            baseRequest.setAttribute("org.eclipse.jetty.servlet.REGEX_PATH",null);
+        
+        super.nextHandle(path,baseRequest,request,response);
+    }
+
+    /* ------------------------------------------------------------ */
+    public void dump(Appendable out, String indent) throws IOException
+    {
+        AggregateLifeCycle.dumpObject(out,this);
+        AggregateLifeCycle.dump(out,indent,_patterns,Collections.singletonList(getHandler()));
+    }
+    
+    
+}

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

@@ -0,0 +1,214 @@
+// ========================================================================
+// 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. 
+// ========================================================================
+
+package org.eclipse.jetty.rewrite.handler;
+
+import static junit.framework.Assert.assertEquals;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.Servlet;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequestWrapper;
+import javax.servlet.ServletResponseWrapper;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpServletResponseWrapper;
+
+import junit.framework.Assert;
+
+import org.eclipse.jetty.rewrite.handler.RegexTargetHandler;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class RegexTargetHandlerTest
+{
+    private static Server __server = new Server(0);
+    private static int __port;
+    
+    @BeforeClass
+    public static void setup() throws Exception
+    {
+
+        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
+        context.setContextPath("/");
+        __server.setHandler(context);
+
+        // Serve some hello world servlets
+        context.addServlet(DispatchServletServlet.class,"/dispatch/*");
+        context.addServlet(new ServletHolder("HelloAll",new HelloServlet("Hello World")),"/*");
+        context.addServlet(new ServletHolder("Italian",new HelloServlet("Buongiorno Mondo")),"/it/*");
+        context.addServlet(new ServletHolder("French", new HelloServlet("Bonjour le Monde")),"/fr/*");
+
+        RegexTargetHandler regexHandler=new RegexTargetHandler();
+        regexHandler.setHandler(context.getHandler());
+        context.setHandler(regexHandler);
+        
+        context.getInitParams().put(RegexTargetHandler.REGEX_MAPPINGS,
+                "  .*\\.fr==French,   \n"+
+                "/ciao(/.*)$==Italian");
+        
+        __server.start();
+        
+        __port=__server.getConnectors()[0].getLocalPort();
+    }
+
+    @AfterClass
+    public static void shutdown() throws Exception
+    {
+        __server.stop();
+    }
+    
+    
+    @Test
+    public void testNormal() throws Exception
+    {
+        String[] response=getResponse("/normal");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Hello World",response[1]);
+        assertEquals("",response[2]);
+        assertEquals("/normal",response[3]);
+        
+        response=getResponse("/it/info");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Buongiorno Mondo",response[1]);
+        assertEquals("/it",response[2]);
+        assertEquals("/info",response[3]);
+    }
+    
+    @Test
+    public void testFullMatch() throws Exception
+    {
+        String[] response=getResponse("/some/thing.fr");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Bonjour le Monde",response[1]);
+        assertEquals("/some/thing.fr",response[2]);
+        assertEquals("null",response[3]);
+    }
+    
+    @Test
+    public void testCaptureMatch() throws Exception
+    {
+        String[] response=getResponse("/ciao/info");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Buongiorno Mondo",response[1]);
+        assertEquals("/ciao",response[2]);
+        assertEquals("/info",response[3]);
+    }
+    
+    @Test
+    public void testDispatchFullMatch() throws Exception
+    {
+        String[] response=getResponse("/dispatch/xxx?forward=/some/thing.fr");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Bonjour le Monde",response[1]);
+        assertEquals("/some/thing.fr",response[2]);
+        assertEquals("null",response[3]);
+    }
+    
+    @Test
+    public void testDispatchCaptureMatch() throws Exception
+    {
+        String[] response=getResponse("/dispatch/xxx?forward=/ciao/info");
+        assertEquals("HTTP/1.1 200 OK",response[0]);
+        assertEquals("Buongiorno Mondo",response[1]);
+        assertEquals("/ciao",response[2]);
+        assertEquals("/info",response[3]);
+    }
+    
+    
+    private String[] getResponse(String uri) throws Exception
+    {
+        Socket socket = new Socket("127.0.0.1",__port);
+        
+        PrintWriter out = new PrintWriter(socket.getOutputStream());
+        out.print("GET "+uri+" HTTP/1.0\r\n\r\n");
+        out.flush();
+        
+        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+        
+        String[] response=new String[4];
+        response[0]=in.readLine();
+        //System.err.println(response[0]);
+        
+        String line=in.readLine();
+        while(line.length()>0)
+            line=in.readLine();
+        
+        response[1]=in.readLine();
+        //System.err.println(response[1]);
+        response[2]=in.readLine();
+        //System.err.println(response[2]);
+        response[3]=in.readLine();
+        //System.err.println(response[3]);
+   
+        socket.close();
+        return response;
+    }
+    
+    
+    public static class HelloServlet extends HttpServlet implements Servlet
+    {
+        final String _hello;
+        
+        public HelloServlet(String hello)
+        {
+            _hello=hello;
+        }
+        
+        @Override
+        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
+        {
+            response.setStatus(200);
+            response.getWriter().println(_hello);
+            response.getWriter().println(request.getServletPath());
+            response.getWriter().println(request.getPathInfo());
+        }
+    }
+    
+    
+    public static class DispatchServletServlet extends HttpServlet implements Servlet
+    {
+        @Override
+        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
+        {
+            RequestDispatcher dispatcher = null;
+
+            if(request.getParameter("include")!=null)
+            {
+                dispatcher = getServletContext().getRequestDispatcher(request.getParameter("include"));
+                dispatcher.include(new HttpServletRequestWrapper(request), new HttpServletResponseWrapper(response));
+            }
+            else if(request.getParameter("forward")!=null)
+            {
+                dispatcher = getServletContext().getRequestDispatcher(request.getParameter("forward"));
+                dispatcher.forward(new HttpServletRequestWrapper(request), new HttpServletResponseWrapper(response));
+            }
+            
+        }
+    }
+}

jetty-security/src/main/java/org/eclipse/jetty/security/SecurityHandler.java

@@ -306,7 +306,7 @@ public abstract class SecurityHandler extends HandlerWrapper implements Authenti
             if (_identityService==null)
                 _identityService=findIdentityService();
             
-            if (_identityService==null && _realmName!=null)
+            if (_identityService==null && _loginService!=null)
                 _identityService=new DefaultIdentityService();
         }
         

jetty-servlet/src/main/java/org/eclipse/jetty/servlet/ServletHolder.java

@@ -85,7 +85,17 @@ public class ServletHolder extends Holder<Servlet> implements UserIdentity.Scope
     {
         super (Source.EMBEDDED);
     }
+
     
+    /* ---------------------------------------------------------------- */
+    /** Constructor for existing servlet.
+     */
+    public ServletHolder(String name,Servlet servlet)
+    {
+        setName(name);
+        setServlet(servlet);
+    }
+
     
     /* ---------------------------------------------------------------- */
     /** Constructor .
@@ -105,7 +115,16 @@ public class ServletHolder extends Holder<Servlet> implements UserIdentity.Scope
     }
 
     /* ---------------------------------------------------------------- */
-    /** Constructor for existing servlet.
+    /** Constructor for servlet class.
+     */
+    public ServletHolder(String name,Class<? extends Servlet> servlet)
+    {
+        setName(name);
+        setHeldClass(servlet);
+    }
+    
+    /* ---------------------------------------------------------------- */
+    /** Constructor for servlet class.
      */
     public ServletHolder(Class<? extends Servlet> servlet)
     {

jetty-servlet/src/test/java/org/eclipse/jetty/servlet/DispatcherTest.java

@@ -347,11 +347,16 @@ public class DispatcherTest
             RequestDispatcher dispatcher = null;
 
             if(request.getParameter("include")!=null)
+            {
                 dispatcher = getServletContext().getRequestDispatcher(request.getParameter("include"));
+                dispatcher.include(new ServletRequestWrapper(request), new ServletResponseWrapper(response));
+            }
             else if(request.getParameter("forward")!=null)
+            {
                 dispatcher = getServletContext().getRequestDispatcher(request.getParameter("forward"));
+                dispatcher.forward(new ServletRequestWrapper(request), new ServletResponseWrapper(response));
+            }
             
-            dispatcher.forward(new ServletRequestWrapper(request), new ServletResponseWrapper(response));
         }
     }