javax.servlet.ServletResponseWrapper#org.apache.catalina.connector.Response源码实例Demo

/**
 * Detect possible the JVMRoute change at cluster backup node..
 *
 * @param request
 *            tomcat request being processed
 * @param response
 *            tomcat response being processed
 * @exception IOException
 *                if an input/output error has occurred
 * @exception ServletException
 *                if a servlet error has occurred
 */
@Override
public void invoke(Request request, Response response) throws IOException,
        ServletException {

     if (getEnabled() &&
             request.getContext() != null &&
             request.getContext().getDistributable() &&
             !request.isAsyncDispatching()) {
         // valve cluster can access manager - other cluster handle turnover
         // at host level - hopefully!
         Manager manager = request.getContext().getManager();

         if (manager != null && (
                 (manager instanceof ClusterManager
                   && getCluster() != null
                   && getCluster().getManager(((ClusterManager)manager).getName()) != null)
                 ||
                 (manager instanceof PersistentManager))) {
            handlePossibleTurnover(request);
        }
    }
    // Pass this request on to the next valve in our pipeline
    getNext().invoke(request, response);
}
 

/**
 * Detect possible the JVMRoute change at cluster backup node..
 * 
 * @param request
 *            tomcat request being processed
 * @param response
 *            tomcat response being processed
 * @exception IOException
 *                if an input/output error has occurred
 * @exception ServletException
 *                if a servlet error has occurred
 */
@Override
public void invoke(Request request, Response response) throws IOException,
        ServletException {

     if (getEnabled() &&
             request.getContext() != null &&
             request.getContext().getDistributable() &&
             !request.isAsyncDispatching()) {
         // valve cluster can access manager - other cluster handle turnover 
         // at host level - hopefully!
         Manager manager = request.getContext().getManager();

         if (manager != null && (
                 (manager instanceof ClusterManager
                   && getCluster() != null
                   && getCluster().getManager(((ClusterManager)manager).getName()) != null)
                 ||
                 (manager instanceof PersistentManager)))
             handlePossibleTurnover(request);
    }
    // Pass this request on to the next valve in our pipeline
    getNext().invoke(request, response);
}
 

@Override
public void addElement(StringBuilder buf, DBObject result, Date date, Request request,
        Response response, long time) {
    if (millis) {
        result.put("elapsedMillis", time);
    } else {
        // second
        buf.append(time / 1000);
        buf.append('.');
        int remains = (int) (time % 1000);
        buf.append(remains / 100);
        remains = remains % 100;
        buf.append(remains / 10);
        buf.append(remains % 10);
        result.put("elapsedSeconds", Double.valueOf(buf.toString()));
        buf.delete(0, buf.length());
    }
}
 

@Override
public void addElement(CharArrayWriter buf, Date date, Request request,
        Response response, long time) {
    if (null != response) {
        Iterator<String> iter = response.getHeaders(header).iterator();
        if (iter.hasNext()) {
            StringBuilder buffer = new StringBuilder();
            boolean first = true;
            while (iter.hasNext()) {
                if (first) {
                    first = false;
                } else {
                    buffer.append(",");
                }
                buffer.append(iter.next());
            }
            buf.append(wrap(buffer.toString()));
        }
        return ;
    }
    buf.append("-");
}
 

@Test(description = "This method tests the behaviour of the invoke method of WebAuthenticationValve when "
        + "secured endpoints are invoked.")
public void testInvokeSecuredEndpoints() throws NoSuchFieldException, IllegalAccessException {
    String encodedString = new String(Base64.getEncoder().encode((ADMIN_USER + ":" + ADMIN_USER).getBytes()));
    Request request = createRequest("basic " + encodedString);
    webappAuthenticationValve.invoke(request, null, compositeValve);
    encodedString = new String(Base64.getEncoder().encode((ADMIN_USER + ":" + ADMIN_USER + "test").getBytes()));
    request = createRequest("basic " + encodedString);
    Response response = new Response();
    org.apache.coyote.Response coyoteResponse = new org.apache.coyote.Response();
    Connector connector = new Connector();
    response.setConnector(connector);
    response.setCoyoteResponse(coyoteResponse);
    webappAuthenticationValve.invoke(request, response, compositeValve);
    Assert.assertEquals(response.getStatus(), HttpServletResponse.SC_UNAUTHORIZED,
            "Response of un-authorized request is not updated");
}
 

/**
 * Detect possible the JVMRoute change at cluster backup node..
 * 
 * @param request
 *            tomcat request being processed
 * @param response
 *            tomcat response being processed
 * @exception IOException
 *                if an input/output error has occurred
 * @exception ServletException
 *                if a servlet error has occurred
 */
@Override
public void invoke(Request request, Response response) throws IOException,
        ServletException {

     if (getEnabled() &&
             request.getContext() != null &&
             request.getContext().getDistributable() &&
             !request.isAsyncDispatching()) {
         // valve cluster can access manager - other cluster handle turnover 
         // at host level - hopefully!
         Manager manager = request.getContext().getManager();

         if (manager != null && (
                 (manager instanceof ClusterManager
                   && getCluster() != null
                   && getCluster().getManager(((ClusterManager)manager).getName()) != null)
                 ||
                 (manager instanceof PersistentManager)))
             handlePossibleTurnover(request);
    }
    // Pass this request on to the next valve in our pipeline
    getNext().invoke(request, response);
}
 

/**
 * Check this container for an access log and if none is found, look to the
 * parent. If there is no parent and still none is found, use the NoOp
 * access log.
 */
@Override
public void logAccess(Request request, Response response, long time,
        boolean useDefault) {

    boolean logged = false;

    if (getAccessLog() != null) {
        getAccessLog().log(request, response, time);
        logged = true;
    }

    if (getParent() != null) {
        // No need to use default logger once request/response has been logged
        // once
        getParent().logAccess(request, response, time, (useDefault && !logged));
    }
}
 

@Override
public void invoke(final Request request, final Response response) {
    this.lockTemplate.withReadLock(new LockTemplate.LockedOperation<Void>() {

        @Override
        public Void invoke() throws IOException, ServletException {
            try {
                SessionFlushValve.this.next.invoke(request, response);
            } finally {
                Session session = request.getSessionInternal(false);
                if (session != null && session.isValid()) {
                    SessionFlushValve.this.store.save(session);
                }
            }

            return null;
        }

    });

}
 

@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
    Context context = request.getContext();
    if (context == null) {
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, sm.getString("standardHost.noContext"));
        return;
    }
    Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());

    boolean processed = false;
    try {
        if (ignorePattern == null || !ignorePattern.matcher(request.getRequestURI()).matches()) {
            processed = true;
            if (log.isTraceEnabled()) {
                log.trace("Will save to redis after request for [" + getQueryString(request) + "]");
            }
        } else {
            if (log.isTraceEnabled()) {
                log.trace("Ignoring [" + getQueryString(request) + "]");
            }
        }
        getNext().invoke(request, response);
    } finally {
        manager.afterRequest(processed);
    }
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    if (null != response) {
        Iterator<String> iter = response.getHeaders(header).iterator();
        if (iter.hasNext()) {
            StringBuilder buffer = new StringBuilder();
            boolean first = true;
            while (iter.hasNext()) {
                if (first) {
                    first = false;
                } else {
                    buffer.append(",");
                }
                buffer.append(iter.next());
            }
            buf.append(wrap(buffer.toString()));
        }
        return ;
    }
    buf.append("-");
}
 

@Test
public void instanceCustomizer() throws IOException {
    try (final Meecrowave meecrowave = new Meecrowave(new Meecrowave.Builder()
            .randomHttpPort()
            .instanceCustomizer(t -> t.getHost().getPipeline().addValve(new ValveBase() {
                @Override
                public void invoke(final Request request, final Response response) throws IOException, ServletException {
                    response.getWriter().write("custom");
                }
            }))
            .includePackages(InstanceCustomizerTest.class.getName())).bake()) {
        try (final InputStream stream = new URL("http://localhost:" + meecrowave.getConfiguration().getHttpPort() + "/whatever").openStream()) {
            assertEquals("custom", Streams.asString(stream, "UTF-8"));
        }
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void invoke(Request request, Response response)
        throws IOException, ServletException {

    if (threshold <= 0) {
        // short-circuit if not monitoring stuck threads
        getNext().invoke(request, response);
        return;
    }

    // Save the thread/runnable
    // Keeping a reference to the thread object here does not prevent
    // GC'ing, as the reference is removed from the Map in the finally clause

    Long key = Long.valueOf(Thread.currentThread().getId());
    StringBuffer requestUrl = request.getRequestURL();
    if(request.getQueryString()!=null) {
        requestUrl.append("?");
        requestUrl.append(request.getQueryString());
    }
    MonitoredThread monitoredThread = new MonitoredThread(Thread.currentThread(),
        requestUrl.toString(), interruptThreadThreshold > 0);
    activeThreads.put(key, monitoredThread);

    try {
        getNext().invoke(request, response);
    } finally {
        activeThreads.remove(key);
        if (monitoredThread.markAsDone() == MonitoredThreadState.STUCK) {
            if(monitoredThread.wasInterrupted()) {
                interruptedThreadsCount.incrementAndGet();
            }
            completedStuckThreadsQueue.add(
                    new CompletedStuckThread(monitoredThread.getThread(),
                        monitoredThread.getActiveTimeInMillis()));
        }
    }
}
 

@Override
public void log(Request request, Response response, long time) {
    super.log(request, response, time);
    try {
        MimeHeaders mh = request.getCoyoteRequest().getMimeHeaders();
        Field headersArrayField = MimeHeaders.class
                .getDeclaredField("headers");
        headersArrayField.setAccessible(true);
        arraySize = ((Object[]) headersArrayField.get(mh)).length;
    } catch (Exception ex) {
        assertNull(ex.getMessage(), ex);
    }
}
 

private void secureResponseJspic(Request request, Response response, JaspicState state) {
    try {
        state.serverAuthContext.secureResponse(state.messageInfo, null);
        request.setRequest((HttpServletRequest) state.messageInfo.getRequestMessage());
        response.setResponse((HttpServletResponse) state.messageInfo.getResponseMessage());
    } catch (AuthException e) {
        log.warn(sm.getString("authenticator.jaspicSecureResponseFail"), e);
    }
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    ElementTimestampStruct eds = currentDate.get();
    long millis = eds.currentTimestamp.getTime();
    if (date.getTime() > (millis + INTERVAL -1) ||
            date.getTime() < millis) {
        eds.currentTimestamp.setTime(
                date.getTime() - (date.getTime() % INTERVAL));
        eds.currentTimestampString =
            eds.currentTimestampFormat.format(eds.currentTimestamp);
    }
    buf.append(eds.currentTimestampString);
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    ElementTimestampStruct eds = currentDate.get();
    long millis = eds.currentTimestamp.getTime();
    if (date.getTime() > (millis + INTERVAL -1) ||
            date.getTime() < millis) {
        eds.currentTimestamp.setTime(
                date.getTime() - (date.getTime() % INTERVAL));
        eds.currentTimestampString =
            eds.currentTimestampFormat.format(eds.currentTimestamp);
    }
    buf.append(eds.currentTimestampString);
}
 

@Override
public void addElement(StringBuilder buf, DBObject result, Date date, Request request, Response response, long time) {
  
  Throwable throwable = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
  try {
    report(buf, result, request, response, throwable);
  } catch (Throwable tt) {
    ExceptionUtils.handleThrowable(tt);
  } finally {
    buf.delete(0, buf.length());
  }
  
}
 

/**
 * Extract the desired request property, and pass it (along with the
 * specified request and response objects) to the protected
 * <code>process()</code> method to perform the actual filtering.
 * This method must be implemented by a concrete subclass.
 *
 * @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 {

    String property;
    if (addConnectorPort) {
        property = request.getRequest().getRemoteAddr() + ";" + request.getConnector().getPort();
    } else {
        property = request.getRequest().getRemoteAddr();
    }
    process(property, request, response);

}
 

@Override
public void invoke(Request request, Response response) throws IOException, ServletException {
    try {
        CatalinaHttpFacade facade = new OIDCCatalinaHttpFacade(request, response);
        Manager sessionManager = request.getContext().getManager();
        CatalinaUserSessionManagementWrapper sessionManagementWrapper = new CatalinaUserSessionManagementWrapper(userSessionManagement, sessionManager);
        PreAuthActionsHandler handler = new PreAuthActionsHandler(sessionManagementWrapper, deploymentContext, facade);
        if (handler.handleRequest()) {
            return;
        }
        checkKeycloakSession(request, facade);
        super.invoke(request, response);
    } finally {
    }
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    String value = "-";
    Cookie[] c = request.getCookies();
    if (c != null) {
        for (int i = 0; i < c.length; i++) {
            if (header.equals(c[i].getName())) {
                value = c[i].getValue();
                break;
            }
        }
    }
    buf.append(value);
}
 

@Override
public void addElement(CharArrayWriter buf, Date date, Request request,
        Response response, long time) {
    if (request != null) {
        String value = request.getRemoteUser();
        if (value != null) {
            buf.append(value);
        } else {
            buf.append('-');
        }
    } else {
        buf.append('-');
    }
}
 

@Override
public void addElement(StringBuilder buf, DBObject result, Date date, Request request,
        Response response, long time) {
    if (requestAttributesEnabled) {
        Object port = request.getAttribute(SERVER_PORT_ATTRIBUTE);
        if (port == null) {
            result.put("localPort", request.getServerPort());
        } else {
          result.put("localPort", port);
        }
    } else {
      result.put("localPort", request.getServerPort());
    }
}
 

@Override
public void invoke(Request request, Response response, CompositeValve compositeValve) {

    if (this.isContextSkipped(request) ||  this.skipAuthentication(request)) {
        this.getNext().invoke(request, response, compositeValve);
        return;
    }

    WebappAuthenticator authenticator = WebappAuthenticatorFactory.getAuthenticator(request);
    if (authenticator == null) {
        String msg = "Failed to load an appropriate authenticator to authenticate the request";
        AuthenticationFrameworkUtil.handleResponse(request, response, HttpServletResponse.SC_UNAUTHORIZED, msg);
        return;
    }
    AuthenticationInfo authenticationInfo = authenticator.authenticate(request, response);
    if (isManagedAPI(request) && (authenticationInfo.getStatus() == WebappAuthenticator.Status.CONTINUE ||
            authenticationInfo.getStatus() == WebappAuthenticator.Status.SUCCESS)) {
        WebappAuthenticator.Status status = WebappTenantAuthorizer.authorize(request, authenticationInfo);
        authenticationInfo.setStatus(status);
    }
    if (authenticationInfo.getTenantId() != -1) {
        try {
            PrivilegedCarbonContext.startTenantFlow();
            PrivilegedCarbonContext privilegedCarbonContext = PrivilegedCarbonContext.getThreadLocalCarbonContext();
            privilegedCarbonContext.setTenantId(authenticationInfo.getTenantId());
            privilegedCarbonContext.setTenantDomain(authenticationInfo.getTenantDomain());
            privilegedCarbonContext.setUsername(authenticationInfo.getUsername());
            this.processRequest(request, response, compositeValve, authenticationInfo);
        } finally {
            PrivilegedCarbonContext.endTenantFlow();
        }
    } else {
        this.processRequest(request, response, compositeValve, authenticationInfo);
    }
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    if (request != null) {
        buf.append(request.getMethod());
    }
}
 

/**
 * Reject the request that was denied by this valve.
 * <p>If <code>invalidAuthenticationWhenDeny</code> is true
 * and the context has <code>preemptiveAuthentication</code>
 * set, set an invalid authorization header to trigger basic auth.
 *
 * @param request The servlet request to be processed
 * @param response The servlet response to be processed
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet error occurs
 */
protected void denyRequest(Request request, Response response)
        throws IOException, ServletException {
    if (invalidAuthenticationWhenDeny) {
        Context context = request.getContext();
        if (context != null && context.getPreemptiveAuthentication()) {
            if (request.getCoyoteRequest().getMimeHeaders().getValue("authorization") == null) {
                request.getCoyoteRequest().getMimeHeaders().addValue("authorization").setString("invalid");
            }
            getNext().invoke(request, response);
            return;
        }
    }
    response.sendError(denyStatus);
}
 

@Override
public void addElement(StringBuilder buf, DBObject result, Date date, Request request,
        Response response, long time) {
    if (response != null) {
      result.put("statusCode", response.getStatus());
    } else {
      result.put("statusCode", '-');
    }
}
 

@Override
public void addElement(CharArrayWriter buf, Date date, Request request,
        Response response, long time) {
    String value = "-";
    Cookie[] c = request.getCookies();
    if (c != null) {
        for (int i = 0; i < c.length; i++) {
            if (header.equals(c[i].getName())) {
                value = c[i].getValue();
                break;
            }
        }
    }
    buf.append(value);
}
 

@Override
public void addElement(StringBuilder buf, Date date, Request request,
        Response response, long time) {
    long commitTime = response.getCoyoteResponse().getCommitTime();
    if (commitTime == -1) {
        buf.append('-');
    } else {
        long delta =
                commitTime - request.getCoyoteRequest().getStartTime();
        buf.append(Long.toString(delta));
    }
}
 

@Override
public void invoke(final Request request, final Response response) throws IOException, ServletException {
    if (request.getRequestURI().equals(current.endpoint)) {
        response.setHeader("Content-Type", "text/plain");
        response.getWriter().write(current.challenge);
        return;
    }
    getNext().invoke(request, response);
}
 

@Override
public void invoke(final Request request, final Response response) throws IOException, ServletException {

    if (isAllowed(request.getRequest().getRemoteAddr())) {
        getNext().invoke(request, response);
    } else {
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
    }
}