Class AbstractProcessorLight

java/org/apache/coyote/AbstractProcessorLight.java:34–234

This is a light-weight abstract processor implementation that is intended as a basis for all Processor implementations from the light-weight upgrade processors to the HTTP/AJP processors.

 * implementations from the light-weight upgrade processors to the HTTP/AJP processors.
 */
public abstract class AbstractProcessorLight implements Processor {

    /** The set of dispatch types to be processed. */
    private final Set<DispatchType> dispatches = new CopyOnWriteArraySet<>();


    /**
     * Constructs a new processor.
     */
    public AbstractProcessorLight() {
    }


    @Override
    public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status) throws IOException {

        SocketState state = SocketState.CLOSED;
        Iterator<DispatchType> dispatches = null;
        do {
            if (dispatches != null) {
                DispatchType nextDispatch = dispatches.next();
                if (getLog().isTraceEnabled()) {
                    getLog().trace("Processing dispatch type: [" + nextDispatch + "]");
                }
                state = dispatch(nextDispatch.getSocketStatus());
                if (!dispatches.hasNext()) {
                    state = checkForPipelinedData(state, socketWrapper);
                }
            } else if (status == SocketEvent.DISCONNECT) {
                // Do nothing here, just wait for it to get recycled
            } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
                state = dispatch(status);
                state = checkForPipelinedData(state, socketWrapper);
            } else if (status == SocketEvent.OPEN_WRITE) {
                // Extra write event likely after async, ignore
                state = SocketState.LONG;
            } else if (status == SocketEvent.OPEN_READ) {
                state = service(socketWrapper);
            } else if (status == SocketEvent.CONNECT_FAIL) {
                logAccess(socketWrapper);
            } else {
                // Default to closing the socket if the SocketEvent passed in
                // is not consistent with the current state of the Processor
                state = SocketState.CLOSED;
            }

            if (getLog().isTraceEnabled()) {
                getLog().trace(
                        "Socket: [" + socketWrapper + "], Status in: [" + status + "], State out: [" + state + "]");
            }

            /*
             * If state is already CLOSED don't call asyncPostProcess() as that will likely change the state to some
             * other value causing processing to continue when it should cease. The AsyncStateMachine will be recycled
             * as part of the Processor clean-up on CLOSED so it doesn't matter what state it is left in at this point.
             */
            if (isAsync() && state != SocketState.CLOSED) {
                state = asyncPostProcess();