code:     public final void invoke(Request request, Response response)
          throws IOException, ServletException {
  
          // 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;
          }
  
          if (request.isAsyncSupported()) {
              request.setAsyncSupported(context.getPipeline().isAsyncSupported());
          }
  
          boolean asyncAtStart = request.isAsync();
          boolean asyncDispatching = request.isAsyncDispatching();
  
          try {
              context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
  
              if (!asyncAtStart && !context.fireRequestInitEvent(request.getRequest())) {
                  // Don't fire listeners during async processing (the listener
                  // fired for the request that called startAsync()).
                  // If a request init listener throws an exception, the request
                  // is aborted.
                  return;
              }
  
              // 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);
                  container.getLogger().error("Exception Processing " + request.getRequestURI(), t);
                  // If a new error occurred while trying to report a previous
                  // error allow the original error to be reported.
                  if (!response.isErrorReportRequired()) {
                      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) {
                  context.fireRequestDestroyEvent(request.getRequest());
              }
          } finally {
              // Access a session (if present) to update last accessed time, based
              // on a strict interpretation of the specification
              if (ACCESS_SESSION) {
                  request.getSession(false);
              }
  
              context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
          }
      }
  
  
      // -------------------------------------------------------- Private Methods
  
      /**
       * Handle the HTTP status code (and corresponding message) generated
       * while processing the specified Request to produce the specified
       * Response.  Any exceptions that occur during generation of the error
       * report are logged and swallowed.
       *
       * @param request The request being processed
       * @param response The response being generated
       */
  