Examples of org.mortbay.jetty.Request

org.mortbay.jetty.Request
Jetty Request.
Implements {@link javax.servlet.HttpServletRequest} from the {@link javax.servlet} package.

The standard interface of mostly getters, is extended with setters so that the request is mutable by the handlers that it is passed to. This allows the request object to be as lightweight as possible and not actually implement any significant behaviour. For example
- The {@link getContextPath} method will return null, until the requeset has been passed to a {@link ContextHandler} which matches the {@link getPathInfo} with a contextpath and calls {@link setContextPath} as a result.
- the HTTP session methods will all return null sessions until such time as a request has been passed to a {@link org.mortbay.jetty.servlet.SessionHandler} which checks for session cookiesand enables the ability to create new sessions.
- The {@link getServletPath} method will return null until the request has beenpassed to a {@link org.mortbay.jetty.servlet.ServletHandler} and the pathInfo matchedagainst the servlet URL patterns and {@link setServletPath} called as a result.
A request instance is created for each {@link HttpConnection} accepted by the server and recycled for each HTTP request received via that connection. An effort is made to avoid reparsing headers and cookies that are likely to be the same for requests from the same connection. @author gregw

    /* 
     * @see org.mortbay.jetty.Handler#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, int)
     */
    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException
    {      
        Request base_request = request instanceof Request?(Request)request:HttpConnection.getCurrentConnection().getRequest();
        
        if (response.isCommitted() || base_request.isHandled())
            return;
        base_request.setHandled(true);
        
        String method=request.getMethod();


        // little cheat for common request
        if (_serveIcon && _favicon!=null && method.equals(HttpMethods.GET) && request.getRequestURI().equals("/favicon.ico"))

View Full Code Here

    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch)
            throws IOException, ServletException
    {
        setRequestedId(request, dispatch);
        
        Request base_request = (request instanceof Request) ? (Request)request:HttpConnection.getCurrentConnection().getRequest();
        SessionManager old_session_manager=null;
        HttpSession old_session=null;
        
        try
        {
            old_session_manager = base_request.getSessionManager();
            old_session = base_request.getSession(false);
            
            if (old_session_manager != _sessionManager)
            {
                // new session context
                base_request.setSessionManager(_sessionManager);
                base_request.setSession(null);
            }
            
            // access any existing session
            HttpSession session=null;
            if (_sessionManager!=null)
            {
                session=base_request.getSession(false);
                if (session!=null)
                {
                    if(session!=old_session)
                    {
                        Cookie cookie = _sessionManager.access(session,request.isSecure());
                        if (cookie!=null ) // Handle changed ID or max-age refresh
                            response.addCookie(cookie);
                    }
                }
                else 
                {
                    session=base_request.recoverNewSession(_sessionManager);
                    if (session!=null)
                        base_request.setSession(session);
                }
            }
            
            if(Log.isDebugEnabled())
            {
                Log.debug("sessionManager="+_sessionManager);
                Log.debug("session="+session);
            }
        
            getHandler().handle(target, request, response, dispatch);
        }
        catch (RetryRequest r)
        {
            HttpSession session=base_request.getSession(false);
            if (session!=null && session.isNew())
                base_request.saveNewSession(_sessionManager,session);
            throw r;
        }
        finally
        {
            HttpSession session=request.getSession(false);


            if (old_session_manager != _sessionManager)
            {
                //leaving context, free up the session
                if (session!=null)
                    _sessionManager.complete(session);
                
                // Leave last session in place
                if (old_session_manager != null)
                {
                    base_request.setSessionManager(old_session_manager);
                    base_request.setSession(old_session);
                }
            }
        }
    }

View Full Code Here

     * @param request
     * @param dispatch
     */
    protected void setRequestedId(HttpServletRequest request, int dispatch) 
    {
        Request base_request = (request instanceof Request) ? (Request)request:HttpConnection.getCurrentConnection().getRequest();
        String requested_session_id=request.getRequestedSessionId();
        if (dispatch!=REQUEST || requested_session_id!=null)
        {
            return;
        }
        
        final SessionManager sessionManager = getSessionManager();
        boolean requested_session_id_from_cookie=false;
        HttpSession session=null;
        // Look for session id cookie    
        if (_sessionManager.isUsingCookies())
        {
            Cookie[] cookies=request.getCookies();
            if (cookies!=null && cookies.length>0)
            {
                for (int i=0;i<cookies.length;i++)
                {
                    if (sessionManager.getSessionCookie().equalsIgnoreCase(cookies[i].getName()))
                    {
                        if (requested_session_id!=null)
                        {
                            // Multiple jsessionid cookies. Probably due to
                            // multiple paths and/or domains. Pick the first
                            // known session or the last defined cookie.
                            if (sessionManager.getHttpSession(requested_session_id)!=null)
                                break;
                        }


                        requested_session_id=cookies[i].getValue();
                        requested_session_id_from_cookie = true;
                        if(Log.isDebugEnabled())Log.debug("Got Session ID "+requested_session_id+" from cookie");
                        
                        session=sessionManager.getHttpSession(requested_session_id);
                        if (session!=null)
                            base_request.setSession(session);
                    }
                }
            }
        }
        
        if (requested_session_id==null || session==null)
        {
            String uri = request.getRequestURI();


            String prefix=sessionManager.getSessionURLPrefix();
            if (prefix!=null)
            {
                int s = uri.indexOf(prefix);
                if (s>=0)
                {   
                    s+=prefix.length();
                    int i=s;
                    while (i<uri.length())
                    {
                        char c=uri.charAt(i);
                        if (c==';'||c=='#'||c=='?'||c=='/')
                            break;
                        i++;
                    }


                    requested_session_id = uri.substring(s,i);
                    requested_session_id_from_cookie = false;
                    if(Log.isDebugEnabled())
                        Log.debug("Got Session ID "+requested_session_id+" from URL");                    
                }
            }
        }
        
        base_request.setRequestedSessionId(requested_session_id);
        base_request.setRequestedSessionIdFromCookie(requested_session_id!=null && requested_session_id_from_cookie);
    }

View Full Code Here

    /* 
     * @see javax.servlet.RequestDispatcher#include(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
     */
    public void include(ServletRequest request, ServletResponse response) throws ServletException, IOException
    {
        Request base_request=(request instanceof Request)?((Request)request):HttpConnection.getCurrentConnection().getRequest();
        request.removeAttribute(__JSP_FILE); // TODO remove when glassfish 1044 is fixed
        
        // TODO - allow stream or writer????
        
        Attributes old_attr=base_request.getAttributes();
        MultiMap old_params=base_request.getParameters();
        try
        {
            base_request.getConnection().include();
            if (_named!=null)
                _contextHandler.handle(_named, (HttpServletRequest)request, (HttpServletResponse)response, Handler.INCLUDE);
            else 
            {
                String query=_dQuery;
                
                if (query!=null)
                {
                    MultiMap parameters=new MultiMap();
                    UrlEncoded.decodeTo(query,parameters,request.getCharacterEncoding());
                    
                    if (old_params!=null && old_params.size()>0)
                    {
                        // Merge parameters.
                        Iterator iter = old_params.entrySet().iterator();
                        while (iter.hasNext())
                        {
                            Map.Entry entry = (Map.Entry)iter.next();
                            String name=(String)entry.getKey();
                            Object values=entry.getValue();
                            for (int i=0;i<LazyList.size(values);i++)
                                parameters.add(name, LazyList.get(values, i));
                        }
                        
                    }
                    base_request.setParameters(parameters);
                }
                
                IncludeAttributes attr = new IncludeAttributes(old_attr); 
                
                attr._requestURI=_uri;
                attr._contextPath=_contextHandler.getContextPath();
                attr._servletPath=null; // set by ServletHandler
                attr._pathInfo=_path;
                attr._query=query;
                
                base_request.setAttributes(attr);
                
                _contextHandler.handle(_named==null?_path:_named, (HttpServletRequest)request, (HttpServletResponse)response, Handler.INCLUDE);
            }
        }
        finally
        {
            base_request.setAttributes(old_attr);
            base_request.getConnection().included();
            base_request.setParameters(old_params);
        }
    }

View Full Code Here

    /* 
     * @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
     */
    protected void forward(ServletRequest request, ServletResponse response, int dispatch) throws ServletException, IOException
    {
        Request base_request=(request instanceof Request)?((Request)request):HttpConnection.getCurrentConnection().getRequest();
        response.resetBuffer(); 
        request.removeAttribute(__JSP_FILE); // TODO remove when glassfish 1044 is fixed
        
        String old_uri=base_request.getRequestURI();
        String old_context_path=base_request.getContextPath();
        String old_servlet_path=base_request.getServletPath();
        String old_path_info=base_request.getPathInfo();
        String old_query=base_request.getQueryString();
        Attributes old_attr=base_request.getAttributes();
        MultiMap old_params=base_request.getParameters();
        try
        {
            if (_named!=null)
                _contextHandler.handle(_named, (HttpServletRequest)request, (HttpServletResponse)response, dispatch);
            else 
            {
                String query=_dQuery;
                
                if (query!=null)
                {
                    MultiMap parameters=new MultiMap();
                    UrlEncoded.decodeTo(query,parameters,request.getCharacterEncoding());
                 
                    boolean rewrite_old_query = false;


                    if( old_params == null )
                    {
                        base_request.getParameterNames();    // force parameters to be evaluated
                        old_params = base_request.getParameters();
                    }
                    
                    if (old_params!=null && old_params.size()>0)
                    {
                        // Merge parameters; new parameters of the same name take precedence.
                        Iterator iter = old_params.entrySet().iterator();
                        while (iter.hasNext())
                        {
                            Map.Entry entry = (Map.Entry)iter.next();
                            String name=(String)entry.getKey();


                            if (parameters.containsKey(name))
                                rewrite_old_query = true;
                            Object values=entry.getValue();
                            for (int i=0;i<LazyList.size(values);i++)
                                parameters.add(name, LazyList.get(values, i));
                        }
                    }
                    
                    if (old_query != null && old_query.length()>0)
                    {
                        if ( rewrite_old_query )
                        {
                            StringBuffer overridden_query_string = new StringBuffer();
                            MultiMap overridden_old_query = new MultiMap();
                            UrlEncoded.decodeTo(old_query,overridden_old_query,request.getCharacterEncoding());
    
                            MultiMap overridden_new_query = new MultiMap(); 
                            UrlEncoded.decodeTo(query,overridden_new_query,request.getCharacterEncoding());


                            Iterator iter = overridden_old_query.entrySet().iterator();
                            while (iter.hasNext())
                            {
                                Map.Entry entry = (Map.Entry)iter.next();
                                String name=(String)entry.getKey();
                                if(!overridden_new_query.containsKey(name))
                                {
                                    Object values=entry.getValue();
                                    for (int i=0;i<LazyList.size(values);i++)
                                    {
                                        overridden_query_string.append("&"+name+"="+LazyList.get(values, i));
                                    }
                                }
                            }
                            
                            query = query + overridden_query_string;
                        }
                        else 
                        {
                            query=query+"&"+old_query;
                        }
                   }


                    base_request.setParameters(parameters);
                    base_request.setQueryString(query);
                }
                
                ForwardAttributes attr = new ForwardAttributes(old_attr); 
                
                //If we have already been forwarded previously, then keep using the established 
                //original value. Otherwise, this is the first forward and we need to establish the values.
                //Note: the established value on the original request for pathInfo and
                //for queryString is allowed to be null, but cannot be null for the other values.
                if ((String)old_attr.getAttribute(__FORWARD_REQUEST_URI) != null)
                {
                    attr._pathInfo=(String)old_attr.getAttribute(__FORWARD_PATH_INFO);
                    attr._query=(String)old_attr.getAttribute(__FORWARD_QUERY_STRING);
                    attr._requestURI=(String)old_attr.getAttribute(__FORWARD_REQUEST_URI);
                    attr._contextPath=(String)old_attr.getAttribute(__FORWARD_CONTEXT_PATH);
                    attr._servletPath=(String)old_attr.getAttribute(__FORWARD_SERVLET_PATH);
                }
                else
                {
                    attr._pathInfo=old_path_info;
                    attr._query=old_query;
                    attr._requestURI=old_uri;
                    attr._contextPath=old_context_path;
                    attr._servletPath=old_servlet_path;
                }                
   
              
                
                base_request.setRequestURI(_uri);
                base_request.setContextPath(_contextHandler.getContextPath());
                base_request.setAttributes(attr);
                base_request.setQueryString(query);
                
                _contextHandler.handle(_path, (HttpServletRequest)request, (HttpServletResponse)response, dispatch);
                
                if (base_request.getConnection().getResponse().isWriting())
                {
                    try {response.getWriter().close();}
                    catch(IllegalStateException e) { response.getOutputStream().close(); }
                }
                else
                {
                    try {response.getOutputStream().close();}
                    catch(IllegalStateException e) { response.getWriter().close(); }
                }
            }
        }
        finally
        {
            base_request.setRequestURI(old_uri);
            base_request.setContextPath(old_context_path);
            base_request.setServletPath(old_servlet_path);
            base_request.setPathInfo(old_path_info);
            base_request.setAttributes(old_attr);
            base_request.setParameters(old_params);
            base_request.setQueryString(old_query);
        }
    }

View Full Code Here

    {
        Handler[] handlers = getHandlers();
        if (handlers==null || handlers.length==0)
      return;


        Request base_request = HttpConnection.getCurrentConnection().getRequest();
      
        // data structure which maps a request to a context
        // each match is called in turn until the request is handled
        // { context path => 
        //     { virtual host => context } 
        // }
  PathMap map = _contextMap;
  if (map!=null && target!=null && target.startsWith("/"))
  {
            // first, get all contexts matched by context path
      Object contexts = map.getLazyMatches(target);


            for (int i=0; i<LazyList.size(contexts); i++)
            {
                // then, match against the virtualhost of each context
                Map.Entry entry = (Map.Entry)LazyList.get(contexts, i);
                Object list = entry.getValue();


                if (list instanceof Map)
                {
                    Map hosts = (Map)list;
                    String host = normalizeHostname(request.getServerName());


                    // explicitly-defined virtual hosts, most specific
                    list=hosts.get(host);
                    for (int j=0; j<LazyList.size(list); j++)
                    {
                        Handler handler = (Handler)LazyList.get(list,j);
                        handler.handle(target,request, response, dispatch);
                        if (base_request.isHandled())
                            return;
                    }


                    // wildcard for one level of names 
                    list=hosts.get("*."+host.substring(host.indexOf(".")+1));
                    for (int j=0; j<LazyList.size(list); j++)
                    {
                        Handler handler = (Handler)LazyList.get(list,j);
                        handler.handle(target,request, response, dispatch);
                        if (base_request.isHandled())
                            return;
                    }


                    // no virtualhosts defined for the context, least specific
                    // will handle any request that does not match to a specific virtual host above                    
                    list=hosts.get("*");
                    for (int j=0; j<LazyList.size(list); j++)
                    {
                        Handler handler = (Handler)LazyList.get(list,j);
                        handler.handle(target,request, response, dispatch);
                        if (base_request.isHandled())
                            return;
                    }
                }
                else
                {
                    for (int j=0; j<LazyList.size(list); j++)
                    {
                        Handler handler = (Handler)LazyList.get(list,j);
                        handler.handle(target,request, response, dispatch);
                        if (base_request.isHandled())
                            return;
                    }
                }
      }
  }
  else
  {
            // This may not work in all circumstances... but then I think it should never be called
      for (int i=0;i<handlers.length;i++)
      {
    handlers[i].handle(target,request, response, dispatch);
    if ( base_request.isHandled())
        return;
      }
  }
    }

View Full Code Here

        public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException
        {
            if (_newContextURL==null)
                return;
            
            Request base_request=(request instanceof Request)?(Request)request:HttpConnection.getCurrentConnection().getRequest();
            
            String url = _newContextURL;
            if (!_discardPathInfo && request.getPathInfo()!=null)
                url=URIUtil.addPaths(url, request.getPathInfo());
            if (!_discardQuery && request.getQueryString()!=null)
                url+="?"+request.getQueryString();
            
            response.sendRedirect(url);
            if (_permanent)
                response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
            
            base_request.setHandled(true);
        }

View Full Code Here

     * @see org.mortbay.jetty.Handler#handle(java.lang.String, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, int)
     */
    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch)
            throws IOException, ServletException
    {
        final Request srequest = (Request)request;
        final Response sresponse = (Response)response;
        final Thread thread=Thread.currentThread();
        final String old_name=thread.getName();


        boolean suspend=false;
        boolean retry=false;
        String name=(String)request.getAttribute("org.mortbay.jetty.thread.name");
        if (name==null)
            name=old_name+"://"+srequest.getHeader("Host") +srequest.getUri();
        else
            retry=true;
        
        String ex=null;
        try
        {
            final String d=_date.now();
            final int ms=_date.lastMs();
            
            if (retry)
                _print.println(d+(ms>99?".":(ms>9?".0":".00"))+ms+":"+name+" RETRY");
            else
                _print.println(d+(ms>99?".":(ms>9?".0":".00"))+ms+":"+name+" "+srequest.getRemoteAddr()+" "+request.getMethod()+" "+srequest.getHeader("Cookie")+"; "+srequest.getHeader("User-Agent"));
            thread.setName(name);
            super.handle(target, request, response, dispatch);
        }
        catch(RetryRequest r)
        {

View Full Code Here

        }
        
        // Service the request
        boolean servlet_error=true;
        Principal user=null;
        Request base_request=null;
        try
        {
            // Handle aliased path
            if (_forcedPath!=null)
                // TODO complain about poor naming to the Jasper folks
                request.setAttribute("org.apache.catalina.jsp_file",_forcedPath);


            // Handle run as
            if (_runAs!=null && _realm!=null)
            {
                base_request=HttpConnection.getCurrentConnection().getRequest();
                user=_realm.pushRole(base_request.getUserPrincipal(),_runAs);
                base_request.setUserPrincipal(user);
            }
            
            servlet.service(request,response);
            servlet_error=false;
        }
        catch(UnavailableException e)
        {
            makeUnavailable(e);
            throw _unavailableEx;
        }
        finally
        {
            // pop run-as role
            if (_runAs!=null && _realm!=null && user!=null && base_request!=null)
            {
                user=_realm.popRole(user);
                base_request.setUserPrincipal(user);
            }


            // Handle error params.
            if (servlet_error)
                request.setAttribute("javax.servlet.error.servlet_name",getName());

View Full Code Here

    /* 
     * @see org.mortbay.jetty.Handler#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, int)
     */
    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException
    {
        Request base_request = request instanceof Request?(Request)request:HttpConnection.getCurrentConnection().getRequest();
        if (base_request.isHandled())
            return;
        
        boolean skipContentBody = false;
        if(!HttpMethods.GET.equals(request.getMethod()))
        {
            if(!HttpMethods.HEAD.equals(request.getMethod()))
                return;
            skipContentBody = true;
        }
     
        Resource resource=getResource(request);
        
        if (resource==null || !resource.exists())
            return;
        if (!_aliases && resource.getAlias()!=null)
        {
            Log.info(resource+" aliased to "+resource.getAlias());
            return;
        }


        // We are going to server something
        base_request.setHandled(true);
        
        if (resource.isDirectory())
        {
            if (!request.getPathInfo().endsWith(URIUtil.SLASH))
            {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.mortbay.jetty.Request

com.eviware.soapui.impl.wsdl.monitor.jettyproxy.JettyServer

com.google.gwt.dev.codeserver.WebServer

com.noelios.restlet.ext.jetty.JettyHandler

com.springsource.insight.plugin.apache.http.hc3.HttpClientExecutionCollectionAspectTest$TestHandler

com.springsource.insight.plugin.apache.http.hc4.HttpClientExecutionCollectionAspectTest$TestHandler

com.springsource.insight.plugin.socket.HttpURLConnectionOperationCollectionAspectTest$TestHandler

com.springsource.insight.plugin.springweb.http.SimpleClientHttpRequestFactoryCollectionAspectTest$TestHandler

com.springsource.insight.plugin.springweb.remoting.SimpleHttpInvokerRequestExecutorAspectTest$TestHandler

com.twitter.ambrose.server.APIHandler

edu.iu.incntre.flowscalehttplistener.HttpListener

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.