Esempio n. 1
0
 public static void invokeRequest(Valve pipelineHead, Request request)
     throws ServletException, IOException {
   pipelineHead.invoke(request, request.getResponse());
   // StandardHostValve calls request.getSession(false) on way out, so we will too
   request.getSession(false);
   request.recycle();
 }
  /**
   * Register requests for tracking, whenever needed.
   *
   * @param request The servlet request to be processed
   * @param response The servlet response to be created
   * @exception IOException if an input/output error occurs
   * @exception ServletException if a servlet error occurs
   */
  @Override
  public void invoke(Request request, Response response) throws IOException, ServletException {
    // Perform the request
    getNext().invoke(request, response);

    if (request.isComet() && !response.isClosed()) {
      // Start tracking this connection, since this is a
      // begin event, and Comet mode is on
      HttpSession session = request.getSession(true);

      // Track the connection for webapp reload
      cometRequests.add(request);

      // Track the connection for session expiration
      synchronized (session) {
        Request[] requests = (Request[]) session.getAttribute(cometRequestsAttribute);
        if (requests == null) {
          requests = new Request[1];
          requests[0] = request;
          session.setAttribute(cometRequestsAttribute, requests);
        } else {
          Request[] newRequests = new Request[requests.length + 1];
          for (int i = 0; i < requests.length; i++) {
            newRequests[i] = requests[i];
          }
          newRequests[requests.length] = request;
          session.setAttribute(cometRequestsAttribute, newRequests);
        }
      }
    }
  }
 @Override
 public void lifecycleEvent(LifecycleEvent event) {
   if (Lifecycle.BEFORE_STOP_EVENT.equals(event.getType())) {
     // The container is getting stopped, close all current connections
     Iterator<Request> iterator = cometRequests.iterator();
     while (iterator.hasNext()) {
       Request request = iterator.next();
       // Remove the session tracking attribute as it isn't
       // serializable or required.
       HttpSession session = request.getSession(false);
       if (session != null) {
         session.removeAttribute(cometRequestsAttribute);
       }
       // Close the comet connection
       try {
         CometEventImpl cometEvent = request.getEvent();
         cometEvent.setEventType(CometEvent.EventType.END);
         cometEvent.setEventSubType(CometEvent.EventSubType.WEBAPP_RELOAD);
         getNext().event(request, request.getResponse(), cometEvent);
         cometEvent.close();
       } catch (Exception e) {
         container.getLogger().warn(sm.getString("cometConnectionManagerValve.event"), e);
       }
     }
     cometRequests.clear();
   }
 }
 @Override
 public void addElement(
     StringBuilder buf, Date date, Request request, Response response, long time) {
   HttpSession session = null;
   if (request != null) {
     session = request.getSession(false);
     if (session != null) buf.append(wrap(session.getAttribute(attribute)));
   }
 }
  public void testGetSession() {
    String requestedSessionId = "REQUESTED_SESSION_ID";

    Context context = Mockito.mock(Context.class);

    CassandraTemplate template = new TestCassandraTemplate();
    template.setLogSessionsOnStartup(true);
    template.initialize(getClass().getClassLoader());

    CassandraManager manager = new HectorCassandraManager();
    manager.setCassandraTemplate(template);
    Mockito.when(context.getManager()).thenReturn(manager);
    Request request = new Request();
    request.setContext(context);
    // fake cookie sent a value
    request.setRequestedSessionId(requestedSessionId);
    HttpSession session = request.getSession();
    Assert.assertFalse(requestedSessionId.equals(session.getId()));
  }
  /**
   * Process Comet event.
   *
   * @param request Request to be processed
   * @param response Response to be produced
   * @param event the event
   * @exception IOException if an input/output error occurred
   * @exception ServletException if a servlet error occurred
   */
  @Override
  public final void event(Request request, Response response, CometEvent event)
      throws IOException, ServletException {

    // Select the Context to be used for this Request
    Context context = request.getContext();

    // Bind the context CL to the current thread
    if (context.getLoader() != null) {
      // Not started - it should check for availability first
      // This should eventually move to Engine, it's generic.
      Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());
    }

    // Ask this Context to process this request
    context.getPipeline().getFirst().event(request, response, event);

    // Error page processing
    response.setSuspended(false);

    Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

    if (t != null) {
      throwable(request, response, t);
    } else {
      status(request, response);
    }

    // Access a session (if present) to update last accessed time, based on a
    // strict interpretation of the specification
    if (ACCESS_SESSION) {
      request.getSession(false);
    }

    // Restore the context classloader
    Thread.currentThread().setContextClassLoader(StandardHostValve.class.getClassLoader());
  }
  /**
   * Select the appropriate child Context to process this request, based on the specified request
   * URI. If no matching Context can be found, return an appropriate HTTP error.
   *
   * @param request Request to be processed
   * @param response Response to be produced
   * @exception IOException if an input/output error occurred
   * @exception ServletException if a servlet error occurred
   */
  @Override
  public final void invoke(Request request, Response response)
      throws IOException, ServletException {

    /*
     * xujb:
     * 和Engine一样,调用下层的context,让它来做一些处理
     * 自身也处理了一些的逻辑
     *
     * */

    // Select the Context to be used for this Request
    Context context = request.getContext();
    if (context == null) {
      response.sendError(
          HttpServletResponse.SC_INTERNAL_SERVER_ERROR, sm.getString("standardHost.noContext"));
      return;
    }

    // Bind the context CL to the current thread
    if (context.getLoader() != null) {
      // Not started - it should check for availability first
      // This should eventually move to Engine, it's generic.
      if (Globals.IS_SECURITY_ENABLED) {
        PrivilegedAction<Void> pa = new PrivilegedSetTccl(context.getLoader().getClassLoader());
        AccessController.doPrivileged(pa);
      } else {
        Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());
      }
    }
    if (request.isAsyncSupported()) {
      request.setAsyncSupported(context.getPipeline().isAsyncSupported());
    }

    boolean asyncAtStart = request.isAsync();
    boolean asyncDispatching = request.isAsyncDispatching();
    if (asyncAtStart || context.fireRequestInitEvent(request)) {

      // Ask this Context to process this request. Requests that are in
      // async mode and are not being dispatched to this resource must be
      // in error and have been routed here to check for application
      // defined error pages.
      try {
        if (!asyncAtStart || asyncDispatching) {
          context.getPipeline().getFirst().invoke(request, response);
        } else {
          // Make sure this request/response is here because an error
          // report is required.
          if (!response.isErrorReportRequired()) {
            throw new IllegalStateException(sm.getString("standardHost.asyncStateError"));
          }
        }
      } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // If a new error occurred while trying to report a previous
        // error simply log the new error and allow the original error
        // to be reported.
        if (response.isErrorReportRequired()) {
          container.getLogger().error("Exception Processing " + request.getRequestURI(), t);
        } else {
          request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
          throwable(request, response, t);
        }
      }

      // Now that the request/response pair is back under container
      // control lift the suspension so that the error handling can
      // complete and/or the container can flush any remaining data
      response.setSuspended(false);

      Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

      // Protect against NPEs if the context was destroyed during a
      // long running request.
      if (!context.getState().isAvailable()) {
        return;
      }

      // Look for (and render if found) an application level error page
      if (response.isErrorReportRequired()) {
        if (t != null) {
          throwable(request, response, t);
        } else {
          status(request, response);
        }
      }

      if (!request.isAsync() && (!asyncAtStart || !response.isErrorReportRequired())) {
        context.fireRequestDestroyEvent(request);
      }
    }

    // Access a session (if present) to update last accessed time, based on a
    // strict interpretation of the specification
    if (ACCESS_SESSION) {
      request.getSession(false);
    }

    // Restore the context classloader
    if (Globals.IS_SECURITY_ENABLED) {
      PrivilegedAction<Void> pa = new PrivilegedSetTccl(StandardHostValve.class.getClassLoader());
      AccessController.doPrivileged(pa);
    } else {
      Thread.currentThread().setContextClassLoader(StandardHostValve.class.getClassLoader());
    }
  }
  /**
   * Use events to update the connection state.
   *
   * @param request The servlet request to be processed
   * @param response The servlet response to be created
   * @exception IOException if an input/output error occurs
   * @exception ServletException if a servlet error occurs
   */
  @Override
  public void event(Request request, Response response, CometEvent event)
      throws IOException, ServletException {

    // Perform the request
    boolean ok = false;
    try {
      getNext().event(request, response, event);
      ok = true;
    } finally {
      if (!ok
          || response.isClosed()
          || (event.getEventType() == CometEvent.EventType.END)
          || (event.getEventType() == CometEvent.EventType.ERROR
              && !(event.getEventSubType() == CometEvent.EventSubType.TIMEOUT))) {

        // Remove the connection from webapp reload tracking
        cometRequests.remove(request);

        // Remove connection from session expiration tracking
        // Note: can't get the session if it has been invalidated but
        // OK since session listener will have done clean-up
        HttpSession session = request.getSession(false);
        if (session != null) {
          synchronized (session) {
            Request[] reqs = null;
            try {
              reqs = (Request[]) session.getAttribute(cometRequestsAttribute);
            } catch (IllegalStateException ise) {
              // Ignore - session has been invalidated
              // Listener will have cleaned up
            }
            if (reqs != null) {
              boolean found = false;
              for (int i = 0; !found && (i < reqs.length); i++) {
                found = (reqs[i] == request);
              }
              if (found) {
                if (reqs.length > 1) {
                  Request[] newConnectionInfos = new Request[reqs.length - 1];
                  int pos = 0;
                  for (int i = 0; i < reqs.length; i++) {
                    if (reqs[i] != request) {
                      newConnectionInfos[pos++] = reqs[i];
                    }
                  }
                  try {
                    session.setAttribute(cometRequestsAttribute, newConnectionInfos);
                  } catch (IllegalStateException ise) {
                    // Ignore - session has been invalidated
                    // Listener will have cleaned up
                  }
                } else {
                  try {
                    session.removeAttribute(cometRequestsAttribute);
                  } catch (IllegalStateException ise) {
                    // Ignore - session has been invalidated
                    // Listener will have cleaned up
                  }
                }
              }
            }
          }
        }
      }
    }
  }