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

                             HttpServletRequest req,
                             HttpServletResponse resp) throws IOException {
        if (context == null) {
            context = servletContext;
        }
        Request baseRequest = (req instanceof Request) 
            ? (Request)req : HttpConnection.getCurrentConnection().getRequest();
            
        if (getServer().isSetRedirectURL()) {
            resp.sendRedirect(getServer().getRedirectURL());
            resp.flushBuffer();
            baseRequest.setHandled(true);
            return;
        }
        QueryHandlerRegistry queryHandlerRegistry = bus.getExtension(QueryHandlerRegistry.class);
        
        if (null != req.getQueryString() && queryHandlerRegistry != null) {   
            String reqAddr = req.getRequestURL().toString();
            String requestURL =  reqAddr + "?" + req.getQueryString();
            String pathInfo = req.getPathInfo();                     
            for (QueryHandler qh : queryHandlerRegistry.getHandlers()) {
                boolean recognized =
                    qh instanceof StemMatchingQueryHandler
                    ? ((StemMatchingQueryHandler)qh).isRecognizedQuery(requestURL,
                                                                       pathInfo,
                                                                       endpointInfo,
                                                                       contextMatchOnExact())
                    : qh.isRecognizedQuery(requestURL, pathInfo, endpointInfo);
                if (recognized) {
                    //replace the endpointInfo address with request url only for get wsdl   
                    synchronized (endpointInfo) {
                        String oldAddress = updateEndpointAddress(reqAddr);   
                        resp.setContentType(qh.getResponseContentType(requestURL, pathInfo));
                        try {
                            qh.writeResponse(requestURL, pathInfo, endpointInfo, resp.getOutputStream());
                        } catch (Exception ex) {
                            LOG.log(Level.WARNING, "writeResponse failed: ", ex);
                            try {
                                resp.sendError(500, ex.getMessage());
                            } catch (IOException ioe) {
                                //ignore
                            }
                        }
                        endpointInfo.setAddress(oldAddress);
                        resp.getOutputStream().flush();                     
                        baseRequest.setHandled(true);
                        return;    
                    }
                    
                }
            }

View Full Code Here


    protected void serviceRequest(final ServletContext context, 
                                  final HttpServletRequest req, 
                                  final HttpServletResponse resp)
        throws IOException {
        Request baseRequest = (req instanceof Request) 
            ? (Request)req : HttpConnection.getCurrentConnection().getRequest();
        try {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Service http request on thread: " + Thread.currentThread());
            }


            MessageImpl inMessage = new MessageImpl();
            setupMessage(inMessage, context, req, resp);
            
            inMessage.setDestination(this);


            ExchangeImpl exchange = new ExchangeImpl();
            exchange.setInMessage(inMessage);
            exchange.setSession(new HTTPSession(req));
            
            incomingObserver.onMessage(inMessage);


            resp.flushBuffer();
            baseRequest.setHandled(true);
        } finally {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Finished servicing http request on thread: " + Thread.currentThread());
            }
        }

View Full Code Here

        //TODO
        //do we need to check that this request should be handled by this handler?
        if (! target.startsWith(contextPath)) {
            return;
        }
        Request jettyRequest = (Request) req;
        Response jettyResponse = (Response) res;
        res.setContentType("text/xml");
        RequestAdapter request = new RequestAdapter(jettyRequest);
        ResponseAdapter response = new ResponseAdapter(jettyResponse);


        request.setAttribute(WebServiceContainer.SERVLET_REQUEST, req);
        request.setAttribute(WebServiceContainer.SERVLET_RESPONSE, res);
        // TODO: add support for context
        request.setAttribute(WebServiceContainer.SERVLET_CONTEXT, null);


        if (req.getParameter("wsdl") != null) {
            try {
                webServiceContainer.getWsdl(request, response);
                jettyRequest.setHandled(true);
            } catch (IOException e) {
                throw e;
            } catch (Exception e) {
                throw (HttpException) new HttpException(500, "Could not fetch wsdl!").initCause(e);
            }
        } else {
            if (isConfidentialTransportGuarantee) {
                if (!req.isSecure()) {
                    throw new HttpException(403, null);
                }
            } else if (isIntegralTransportGuarantee) {
                if (!jettyRequest.getConnection().isIntegral(jettyRequest)) {
                    throw new HttpException(403, null);
                }
            }
            PolicyContext.setHandlerData((realm == null) ? null : req);
            Thread currentThread = Thread.currentThread();
            ClassLoader oldClassLoader = currentThread.getContextClassLoader();
            currentThread.setContextClassLoader(classLoader);
            //hard to imagine this could be anything but null, but....
//            Subject oldSubject = ContextManager.getCurrentCaller();
            try {
                if (authenticator != null) {
                    String pathInContext = org.mortbay.util.URIUtil.canonicalPath(req.getContextPath());
                    if (authenticator.authenticate(realm, pathInContext, jettyRequest, jettyResponse) == null) {
                        throw new HttpException(403, null);
                    }
                } else {
                    //EJB will figure out correct defaultSubject shortly
                    //TODO consider replacing the GenericEJBContainer.DefaultSubjectInterceptor with this line
                    //setting the defaultSubject.
                    ContextManager.popCallers(null);
                }
                try {
                    webServiceContainer.invoke(request, response);
                    jettyRequest.setHandled(true);
                } catch (IOException e) {
                    throw e;
                } catch (Exception e) {
                    throw (HttpException) new HttpException(500, "Could not process message!").initCause(e);
                }

View Full Code Here

    }


   
   
    protected void doService(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        Request baseRequest = (req instanceof Request) 
            ? (Request)req : HttpConnection.getCurrentConnection().getRequest();
            
        if (getServer().isSetRedirectURL()) {
            resp.sendRedirect(getServer().getRedirectURL());
            resp.flushBuffer();
            baseRequest.setHandled(true);
            return;
        }
        QueryHandlerRegistry queryHandlerRegistry = bus.getExtension(QueryHandlerRegistry.class);
        if (queryHandlerRegistry != null) { 
            String requestURL = req.getRequestURL() + "?" + req.getQueryString();
            String pathInfo = req.getPathInfo();
            for (QueryHandler qh : queryHandlerRegistry.getHandlers()) {
                if (qh.isRecognizedQuery(requestURL, pathInfo, endpointInfo)) {
                    resp.setContentType(qh.getResponseContentType(requestURL, pathInfo));
                    qh.writeResponse(requestURL, pathInfo, endpointInfo, resp.getOutputStream());
                    resp.getOutputStream().flush();                     
                    baseRequest.setHandled(true);
                    return;
                }
            }
        }

View Full Code Here

        serviceRequest(req, resp);
    }


    protected void serviceRequest(final HttpServletRequest req, final HttpServletResponse resp)
        throws IOException {
        Request baseRequest = (req instanceof Request) 
            ? (Request)req : HttpConnection.getCurrentConnection().getRequest();
        try {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Service http request on thread: " + Thread.currentThread());
            }


            MessageImpl inMessage = new MessageImpl();
            inMessage.setContent(InputStream.class, req.getInputStream());
            inMessage.put(HTTP_REQUEST, req);
            inMessage.put(HTTP_RESPONSE, resp);
            inMessage.put(Message.HTTP_REQUEST_METHOD, req.getMethod());
            inMessage.put(Message.PATH_INFO, req.getContextPath() + req.getPathInfo()); 
            inMessage.put(Message.QUERY_STRING, req.getQueryString());
            inMessage.put(Message.CONTENT_TYPE, req.getContentType());
            if (!StringUtils.isEmpty(endpointInfo.getAddress())) {
                inMessage.put(Message.BASE_PATH, new URL(endpointInfo.getAddress()).getPath());
            }
            inMessage.put(Message.FIXED_PARAMETER_ORDER, isFixedParameterOrder());
            inMessage.put(Message.ASYNC_POST_RESPONSE_DISPATCH, Boolean.TRUE);
            inMessage.put(SecurityContext.class, new SecurityContext() {
                public Principal getUserPrincipal() {
                    return req.getUserPrincipal();
                }
                public boolean isUserInRole(String role) {
                    return req.isUserInRole(role);
                }
            });
            
            setHeaders(inMessage);
            inMessage.setDestination(this);
            
            SSLUtils.propogateSecureSession(req, inMessage);


            incomingObserver.onMessage(inMessage);


            resp.flushBuffer();
            baseRequest.setHandled(true);
        } finally {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Finished servicing http request on thread: " + Thread.currentThread());
            }
        }

View Full Code Here

        String old_servlet_path=null;
        String old_path_info=null;
        ClassLoader old_classloader=null;
        Thread current_thread=null;
        
        Request base_request=(request instanceof Request)?(Request)request:HttpConnection.getCurrentConnection().getRequest();
        if( !isStarted() || _shutdown || (dispatch==REQUEST && base_request.isHandled()))
            return;
        
        old_context=base_request.getContext();
        
        // Are we already in this context?
        if (old_context!=_scontext)
        {
            new_context=true;
            
            // Check the vhosts
            if (_vhosts!=null && _vhosts.length>0)
            {
                String vhost = normalizeHostname( request.getServerName());


                boolean match=false;
                
                // TODO non-linear lookup
                for (int i=0;!match && i<_vhosts.length;i++)
                {
                    String contextVhost = _vhosts[i];
                    if(contextVhost==null) continue;
                    if(contextVhost.startsWith("*.")) {
                        // wildcard only at the beginning, and only for one additional subdomain level
                        match=contextVhost.regionMatches(true,2,vhost,vhost.indexOf(".")+1,contextVhost.length()-2);
                    } else
                        match=contextVhost.equalsIgnoreCase(vhost);
                }
                if (!match)
                    return;
            }
            
            // Check the connector
            if (_connectors!=null && _connectors.size()>0)
            {
                String connector=HttpConnection.getCurrentConnection().getConnector().getName();
                if (connector==null || !_connectors.contains(connector))
                    return;
            }
            
            // Nope - so check the target.
            if (dispatch==REQUEST)
            {
                if (_compactPath)
                    target=URIUtil.compactPath(target);
                
                if (target.equals(_contextPath))
                {
                    if (!_allowNullPathInfo && !target.endsWith(URIUtil.SLASH))
                    {
                        base_request.setHandled(true);
                        if (request.getQueryString()!=null)
                            response.sendRedirect(URIUtil.addPaths(request.getRequestURI(),URIUtil.SLASH)+"?"+request.getQueryString());
                        else 
                            response.sendRedirect(URIUtil.addPaths(request.getRequestURI(),URIUtil.SLASH));
                        return;
                    }
                    if (_contextPath.length()>1)
                    {
                        target=URIUtil.SLASH;
                        request.setAttribute("org.mortbay.jetty.nullPathInfo",target);
                    }
                }
                else if (target.startsWith(_contextPath) && (_contextPath.length()==1 || target.charAt(_contextPath.length())=='/'))
                {
                    if (_contextPath.length()>1)
                        target=target.substring(_contextPath.length());
                }
                else 
                {
                    // Not for this context!
                    return;
                }
            }
        }
        
        try
        {
            old_context_path=base_request.getContextPath();
            old_servlet_path=base_request.getServletPath();
            old_path_info=base_request.getPathInfo();
            
            // Update the paths
            base_request.setContext(_scontext);
            if (dispatch!=INCLUDE && target.startsWith("/"))
            {
                if (_contextPath.length()==1)
                    base_request.setContextPath("");
                else
                    base_request.setContextPath(_contextPath);
                base_request.setServletPath(null);
                base_request.setPathInfo(target);
            }


            ServletRequestEvent event=null;
            if (new_context)
            {
                // Set the classloader
                if (_classLoader!=null)
                {
                    current_thread=Thread.currentThread();
                    old_classloader=current_thread.getContextClassLoader();
                    current_thread.setContextClassLoader(_classLoader);
                }
                
                // Handle the REALLY SILLY request events!
                base_request.setRequestListeners(_requestListeners);
                if (_requestAttributeListeners!=null)
                {
                    final int s=LazyList.size(_requestAttributeListeners);
                    for(int i=0;i<s;i++)
                        base_request.addEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i)));
                }
            }
            
            // Handle the request
            try
            {
                if (dispatch==REQUEST && isProtectedTarget(target))
                    throw new HttpException(HttpServletResponse.SC_NOT_FOUND);
                
                Handler handler = getHandler();
                if (handler!=null)
                    handler.handle(target, request, response, dispatch);
            }
            catch(HttpException e)
            {
                Log.debug(e);
                response.sendError(e.getStatus(), e.getReason());
            }
            finally
            {
                // Handle more REALLY SILLY request events!
                if (new_context)
                {
                    base_request.takeRequestListeners();
                    if (_requestAttributeListeners!=null)
                    {
                        for(int i=LazyList.size(_requestAttributeListeners);i-->0;)
                            base_request.removeEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i)));
                    }
                }
            }
        }
        finally
        {
            if (old_context!=_scontext)
            {
                // reset the classloader
                if (_classLoader!=null)
                {
                    current_thread.setContextClassLoader(old_classloader);
                }
                
                // reset the context and servlet path.
                base_request.setContext(old_context);
                base_request.setContextPath(old_context_path);
                base_request.setServletPath(old_servlet_path);
                base_request.setPathInfo(old_path_info); 
            }
        }
    }

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

    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);
                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();
            
            int semi = uri.lastIndexOf(';');
            if (semi>=0)
            {   
                // check if there is a url encoded session param.
                String param=sessionManager.getSessionURL();
                if (param!=null)
                {
                    int p=uri.indexOf(param,semi+1);
                    if (p>0)
                    {
                        requested_session_id = uri.substring(p+param.length()+1);
                        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 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.