org.apache.tomcat.util.net.AbstractEndpoint.Handler.SocketState Java Examples

@Override
public SocketState upgradeDispatch(SocketEvent status) {
    System.out.println("Processing: " + status);
    switch (status) {
    case OPEN_READ:
        // Note: there's always an initial read event at the moment (reading should be skipped since it ends up in the internal buffer)
        break;
    case OPEN_WRITE:
        break;
    case STOP:
    case DISCONNECT:
    case ERROR:
    case TIMEOUT:
    case CONNECT_FAIL:
        return SocketState.CLOSED;
    }
    return SocketState.UPGRADED;
}
 

@Override
protected void doRun() {
    try {
        // Process the request from this socket
        SocketState state = getHandler().process(socketWrapper, event);
        if (state == Handler.SocketState.CLOSED) {
            // Close socket and pool
            closeSocket(socketWrapper.getSocket().longValue());
        }
    } finally {
        socketWrapper = null;
        event = null;
        //return to cache
        if (running && !paused) {
            processorCache.push(this);
        }
    }
}
 

private void doRun() {
    // Process the request from this socket
    if (socket.getSocket() == null) {
        // Closed in another thread
        return;
    }
    SocketState state = handler.process(socket, status);
    if (state == Handler.SocketState.CLOSED) {
        // Close socket and pool
        closeSocket(socket.getSocket().longValue());
        socket.socket = null;
    } else if (state == Handler.SocketState.LONG) {
        socket.access();
        if (socket.async) {
            waitingRequests.add(socket);
        }
    } else if (state == Handler.SocketState.ASYNC_END) {
        socket.access();
        SocketProcessor proc = new SocketProcessor(socket,
                SocketStatus.OPEN_READ);
        getExecutor().execute(proc);
    }
}
 

private void doRun() {
    // Process the request from this socket
    if (socket.getSocket() == null) {
        // Closed in another thread
        return;
    }
    SocketState state = handler.process(socket, status);
    if (state == Handler.SocketState.CLOSED) {
        // Close socket and pool
        closeSocket(socket.getSocket().longValue());
        socket.socket = null;
    } else if (state == Handler.SocketState.LONG) {
        socket.access();
        if (socket.async) {
            waitingRequests.add(socket);
        }
    } else if (state == Handler.SocketState.ASYNC_END) {
        socket.access();
        SocketProcessor proc = new SocketProcessor(socket,
                SocketStatus.OPEN_READ);
        getExecutor().execute(proc);
    }
}
 

SocketState notifyDataAvailable() throws IOException {
    while (isOpen()) {
        switch (getReadState()) {
        case WAITING:
            if (!changeReadState(ReadState.WAITING, ReadState.PROCESSING)) {
                continue;
            }
            try {
                return doOnDataAvailable();
            } catch (IOException e) {
                changeReadState(ReadState.CLOSING);
                throw e;
            }
        case SUSPENDING_WAIT:
            if (!changeReadState(ReadState.SUSPENDING_WAIT, ReadState.SUSPENDED)) {
                continue;
            }
            return SocketState.SUSPENDED;
        default:
            throw new IllegalStateException(
                    sm.getString("wsFrameServer.illegalReadState", getReadState()));
        }
    }

    return SocketState.CLOSED;
}
 

@Override
protected SocketState dispatchEndRequest() {
    // Set keep alive timeout for next request if enabled
    if (keepAliveTimeout > 0) {
        socketWrapper.setReadTimeout(keepAliveTimeout);
    }
    recycle();
    return SocketState.OPEN;
}
 

@Override
protected SocketState dispatchEndRequest() {
    if (!keepAlive) {
        return SocketState.CLOSED;
    } else {
        endRequest();
        inputBuffer.nextRequest();
        outputBuffer.nextRequest();
        if (socketWrapper.isReadPending()) {
            return SocketState.LONG;
        } else {
            return SocketState.OPEN;
        }
    }
}
 

public synchronized SocketState asyncPostProcess() {
    if (state == AsyncState.COMPLETE_PENDING) {
        doComplete();
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.DISPATCH_PENDING) {
        doDispatch();
        return SocketState.ASYNC_END;
    } else  if (state == AsyncState.STARTING) {
        state = AsyncState.STARTED;
        return SocketState.LONG;
    } else if (state == AsyncState.MUST_COMPLETE) {
        asyncCtxt.fireOnComplete();
        state = AsyncState.DISPATCHED;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.COMPLETING) {
        asyncCtxt.fireOnComplete();
        state = AsyncState.DISPATCHED;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.MUST_DISPATCH) {
        state = AsyncState.DISPATCHING;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.DISPATCHING) {
        state = AsyncState.DISPATCHED;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.STARTED) {
        // This can occur if an async listener does a dispatch to an async
        // servlet during onTimeout
        return SocketState.LONG;
    } else {
        throw new IllegalStateException(
                sm.getString("asyncStateMachine.invalidAsyncState",
                        "asyncPostProcess()", state));
    }
}
 

private SocketState checkForPipelinedData(SocketState inState, SocketWrapperBase<?> socketWrapper)
        throws IOException {
    if (inState == SocketState.OPEN) {
        // There may be pipe-lined data to read. If the data isn't
        // processed now, execution will exit this loop and call
        // release() which will recycle the processor (and input
        // buffer) deleting any pipe-lined data. To avoid this,
        // process it now.
        return service(socketWrapper);
    } else {
        return inState;
    }
}
 

@Override
public SocketState service(SocketWrapperBase<?> socket) throws IOException {
    try {
        adapter.service(request, response);
    } catch (Exception e) {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("streamProcessor.service.error"), e);
        }
        response.setStatus(500);
        setErrorState(ErrorState.CLOSE_NOW, e);
    }

    if (!isAsync()) {
        // If this is an async request then the request ends when it has
        // been completed. The AsyncContext is responsible for calling
        // endRequest() in that case.
        endRequest();
    }

    if (getErrorState().isError()) {
        action(ActionCode.CLOSE, null);
        request.updateCounters();
        return SocketState.CLOSED;
    } else if (isAsync()) {
        return SocketState.LONG;
    } else {
        action(ActionCode.CLOSE, null);
        request.updateCounters();
        return SocketState.CLOSED;
    }
}
 

public synchronized SocketState asyncPostProcess() {
    if (state == AsyncState.COMPLETE_PENDING) {
        clearNonBlockingListeners();
        state = AsyncState.COMPLETING;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.DISPATCH_PENDING) {
        clearNonBlockingListeners();
        state = AsyncState.DISPATCHING;
        return SocketState.ASYNC_END;
    } else  if (state == AsyncState.STARTING || state == AsyncState.READ_WRITE_OP) {
        state = AsyncState.STARTED;
        return SocketState.LONG;
    } else if (state == AsyncState.MUST_COMPLETE || state == AsyncState.COMPLETING) {
        asyncCtxt.fireOnComplete();
        state = AsyncState.DISPATCHED;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.MUST_DISPATCH) {
        state = AsyncState.DISPATCHING;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.DISPATCHING) {
        state = AsyncState.DISPATCHED;
        return SocketState.ASYNC_END;
    } else if (state == AsyncState.STARTED) {
        // This can occur if an async listener does a dispatch to an async
        // servlet during onTimeout
        return SocketState.LONG;
    } else {
        throw new IllegalStateException(
                sm.getString("asyncStateMachine.invalidAsyncState",
                        "asyncPostProcess()", state));
    }
}
 

@Override
public void run() {

    synchronized (socket) {
        if (!deferAccept) {
            if (setSocketOptions(socket)) {
                getPoller().add(socket.getSocket().longValue(),
                        getConnectionTimeout(), Poll.APR_POLLIN);
            } else {
                // Close socket and pool
                getHandler().process(socket, SocketEvent.CONNECT_FAIL);
                closeSocket(socket.getSocket().longValue());
                socket = null;
            }
        } else {
            // Process the request from this socket
            if (!setSocketOptions(socket)) {
                // Close socket and pool
                getHandler().process(socket, SocketEvent.CONNECT_FAIL);
                closeSocket(socket.getSocket().longValue());
                socket = null;
                return;
            }
            // Process the request from this socket
            Handler.SocketState state = getHandler().process(socket,
                    SocketEvent.OPEN_READ);
            if (state == Handler.SocketState.CLOSED) {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
            }
        }
    }
}
 

@Override
public void run() {

    synchronized (socket) {
        if (!deferAccept) {
            if (setSocketOptions(socket.getSocket().longValue())) {
                getPoller().add(socket.getSocket().longValue(),
                        getSoTimeout(), true, false);
            } else {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
            }
        } else {
            // Process the request from this socket
            if (!setSocketOptions(socket.getSocket().longValue())) {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
                return;
            }
            // Process the request from this socket
            Handler.SocketState state = handler.process(socket,
                    SocketStatus.OPEN_READ);
            if (state == Handler.SocketState.CLOSED) {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
            } else if (state == Handler.SocketState.LONG) {
                socket.access();
                if (socket.async) {
                    waitingRequests.add(socket);
                }
            }
        }
    }
}
 

public synchronized SocketState asyncPostProcess() {

        // Unpause any non-container threads that may be waiting for this
        // container thread to complete this method. Note because of the syncs
        // those non-container threads won't start back up until until this
        // method exits.
        notifyAll();

        if (state == AsyncState.STARTING) {
            state = AsyncState.STARTED;
            return SocketState.LONG;
        } else if (state == AsyncState.MUST_COMPLETE) {
            asyncCtxt.fireOnComplete();
            state = AsyncState.DISPATCHED;
            return SocketState.ASYNC_END;
        } else if (state == AsyncState.COMPLETING) {
            asyncCtxt.fireOnComplete();
            state = AsyncState.DISPATCHED;
            return SocketState.ASYNC_END;
        } else if (state == AsyncState.MUST_DISPATCH) {
            state = AsyncState.DISPATCHING;
            return SocketState.ASYNC_END;
        } else if (state == AsyncState.DISPATCHING) {
            state = AsyncState.DISPATCHED;
            return SocketState.ASYNC_END;
        } else if (state == AsyncState.STARTED) {
            // This can occur if an async listener does a dispatch to an async
            // servlet during onTimeout
            return SocketState.LONG;
        } else {
            throw new IllegalStateException(
                    sm.getString("asyncStateMachine.invalidAsyncState",
                            "asyncPostProcess()", state));
        }
    }
 

@Override
public void run() {

    synchronized (socket) {
        if (!deferAccept) {
            if (setSocketOptions(socket.getSocket().longValue())) {
                getPoller().add(socket.getSocket().longValue(),
                        getSoTimeout(), true, false);
            } else {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
            }
        } else {
            // Process the request from this socket
            if (!setSocketOptions(socket.getSocket().longValue())) {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
                return;
            }
            // Process the request from this socket
            Handler.SocketState state = handler.process(socket,
                    SocketStatus.OPEN_READ);
            if (state == Handler.SocketState.CLOSED) {
                // Close socket and pool
                closeSocket(socket.getSocket().longValue());
                socket = null;
            } else if (state == Handler.SocketState.LONG) {
                socket.access();
                if (socket.async) {
                    waitingRequests.add(socket);
                }
            }
        }
    }
}
 

/**
 * Process pipelined HTTP requests using the specified input and output
 * streams.
 *
 * @throws IOException error during an I/O operation
 */
@Override
public SocketState event(SocketStatus status)
    throws IOException {

    RequestInfo rp = request.getRequestProcessor();

    try {
        rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
        if (!getAdapter().event(request, response, status)) {
            setErrorState(ErrorState.CLOSE_NOW, null);
        }
    } catch (InterruptedIOException e) {
        setErrorState(ErrorState.CLOSE_NOW, e);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // 500 - Internal Server Error
        response.setStatus(500);
        setErrorState(ErrorState.CLOSE_NOW, t);
        getAdapter().log(request, response, 0);
        log.error(sm.getString("http11processor.request.process"), t);
    }

    rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

    if (getErrorState().isError() || status==SocketStatus.STOP) {
        return SocketState.CLOSED;
    } else if (!comet) {
        inputBuffer.nextRequest();
        outputBuffer.nextRequest();
        return SocketState.OPEN;
    } else {
        return SocketState.LONG;
    }
}
 

/**
 * Process pipelined HTTP requests using the specified input and output
 * streams.
 *
 * @throws IOException error during an I/O operation
 */
@Override
public SocketState event(SocketStatus status)
    throws IOException {

    RequestInfo rp = request.getRequestProcessor();

    try {
        rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
        if (!getAdapter().event(request, response, status)) {
            setErrorState(ErrorState.CLOSE_NOW, null);
        }
    } catch (InterruptedIOException e) {
        setErrorState(ErrorState.CLOSE_NOW, e);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // 500 - Internal Server Error
        response.setStatus(500);
        setErrorState(ErrorState.CLOSE_NOW, t);
        getAdapter().log(request, response, 0);
        log.error(sm.getString("http11processor.request.process"), t);
    }

    rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

    if (getErrorState().isError() || status==SocketStatus.STOP) {
        return SocketState.CLOSED;
    } else if (!comet) {
        inputBuffer.nextRequest();
        outputBuffer.nextRequest();
        return SocketState.OPEN;
    } else {
        return SocketState.LONG;
    }
}
 

private void doRun(SelectionKey key, KeyAttachment ka) {
    try {
        int handshake = -1;

        try {
            if (key != null) {
                // For STOP there is no point trying to handshake as the
                // Poller has been stopped.
                if (socket.isHandshakeComplete() ||
                        status == SocketStatus.STOP) {
                    handshake = 0;
                } else {
                    handshake = socket.handshake(
                            key.isReadable(), key.isWritable());
                    // The handshake process reads/writes from/to the
                    // socket. status may therefore be OPEN_WRITE once
                    // the handshake completes. However, the handshake
                    // happens when the socket is opened so the status
                    // must always be OPEN_READ after it completes. It
                    // is OK to always set this as it is only used if
                    // the handshake completes.
                    status = SocketStatus.OPEN_READ;
                }
            }
        }catch ( IOException x ) {
            handshake = -1;
            if ( log.isDebugEnabled() ) log.debug("Error during SSL handshake",x);
        }catch ( CancelledKeyException ckx ) {
            handshake = -1;
        }
        if ( handshake == 0 ) {
            SocketState state = SocketState.OPEN;
            // Process the request from this socket
            if (status == null) {

                // 最关键的代码，这里将KeyAttachment(实际就是socket)交给Handler处理请求
                state = handler.process(ka, SocketStatus.OPEN_READ);
            } else {
                state = handler.process(ka, status);
            }
            if (state == SocketState.CLOSED) {
                // Close socket and pool
                close(ka, socket, key, SocketStatus.ERROR);
            }
        } else if (handshake == -1 ) {
            close(ka, socket, key, SocketStatus.DISCONNECT);
        } else {
            ka.getPoller().add(socket, handshake);
        }
    } catch (CancelledKeyException cx) {
        socket.getPoller().cancelledKey(key, null, false);
    } catch (OutOfMemoryError oom) {
        try {
            oomParachuteData = null;
            log.error("", oom);
            if (socket != null) {
                socket.getPoller().cancelledKey(key,SocketStatus.ERROR, false);
            }
            releaseCaches();
        }catch ( Throwable oomt ) {
            try {
                System.err.println(oomParachuteMsg);
                oomt.printStackTrace();
            }catch (Throwable letsHopeWeDontGetHere){
                ExceptionUtils.handleThrowable(letsHopeWeDontGetHere);
            }
        }
    } catch (VirtualMachineError vme) {
        ExceptionUtils.handleThrowable(vme);
    }catch ( Throwable t ) {
        log.error("",t);
        if (socket != null) {
            socket.getPoller().cancelledKey(key,SocketStatus.ERROR,false);
        }
    } finally {
        socket = null;
        status = null;
        //return to cache
        if (running && !paused) {
            processorCache.offer(this);
        }
    }
}
 

@Override
public void run() {
    boolean launch = false;
    synchronized (socket) {
        try {
            SocketState state = SocketState.OPEN;

            try {
                // SSL handshake
                serverSocketFactory.handshake(socket.getSocket());
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                if (log.isDebugEnabled()) {
                    log.debug(sm.getString("endpoint.err.handshake"), t);
                }
                // Tell to close the socket
                state = SocketState.CLOSED;
            }

            if ((state != SocketState.CLOSED)) {// 非关闭状态
                if (status == null) {
                    // 调用handler对象的process方法，
                    // 这里handler对象实际上是Http11ConnectionHandler类的实例，
                    // 该对象的初始化过程是在org.apache.coyote.http11.Http11Protocol对象的构造方法中：
                    state = handler.process(socket, SocketStatus.OPEN_READ);
                } else {
                    state = handler.process(socket,status);
                }
            }
            if (state == SocketState.CLOSED) {
                // Close socket
                if (log.isTraceEnabled()) {
                    log.trace("Closing socket:"+socket);
                }
                countDownConnection();
                try {
                    socket.getSocket().close();
                } catch (IOException e) {
                    // Ignore
                }
            } else if (state == SocketState.OPEN ||
                    state == SocketState.UPGRADING ||
                    state == SocketState.UPGRADING_TOMCAT  ||
                    state == SocketState.UPGRADED){
                socket.setKeptAlive(true);
                socket.access();
                launch = true;
            } else if (state == SocketState.LONG) {
                socket.access();
                waitingRequests.add(socket);
            }
        } finally {
            if (launch) {
                try {
                    getExecutor().execute(new SocketProcessor(socket, SocketStatus.OPEN_READ));
                } catch (RejectedExecutionException x) {
                    log.warn("Socket reprocessing request was rejected for:"+socket,x);
                    try {
                        //unable to handle connection at this time
                        handler.process(socket, SocketStatus.DISCONNECT);
                    } finally {
                        countDownConnection();
                    }


                } catch (NullPointerException npe) {
                    if (running) {
                        log.error(sm.getString("endpoint.launch.fail"),
                                npe);
                    }
                }
            }
        }
    }
    socket = null;
    // Finish up this request
}
 

@Override
public SocketState upgradeDispatch(SocketStatus status) throws IOException {
    return null;
}
 

@Override
public SocketState asyncPostProcess() {
    return asyncStateMachine.asyncPostProcess();
}
 

@Override
public SocketState asyncPostProcess() {
    return asyncStateMachine.asyncPostProcess();
}
 

@Override
public final SocketState asyncDispatch(SocketStatus status) {
    return null;
}
 

/**
 * Process pipelined HTTP requests using the specified input and output
 * streams.
 *
 * @throws IOException error during an I/O operation
 */
@Override
public SocketState event(SocketStatus status) throws IOException {

    long soTimeout = endpoint.getSoTimeout();

    RequestInfo rp = request.getRequestProcessor();
    final NioEndpoint.KeyAttachment attach = (NioEndpoint.KeyAttachment)socketWrapper.getSocket().getAttachment();
    try {
        rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
        if (!getAdapter().event(request, response, status)) {
            setErrorState(ErrorState.CLOSE_NOW, null);
        }
        if (!getErrorState().isError()) {
            if (attach != null) {
                attach.setComet(comet);
                if (comet) {
                    Integer comettimeout = (Integer) request.getAttribute(
                            org.apache.coyote.Constants.COMET_TIMEOUT_ATTR);
                    if (comettimeout != null) {
                        attach.setTimeout(comettimeout.longValue());
                    }
                } else {
                    //reset the timeout
                    if (keepAlive) {
                        attach.setTimeout(keepAliveTimeout);
                    } else {
                        attach.setTimeout(soTimeout);
                    }
                }

            }
        }
    } catch (InterruptedIOException e) {
        setErrorState(ErrorState.CLOSE_NOW, e);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // 500 - Internal Server Error
        response.setStatus(500);
        setErrorState(ErrorState.CLOSE_NOW, t);
        log.error(sm.getString("http11processor.request.process"), t);
        getAdapter().log(request, response, 0);
    }

    rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

    if (getErrorState().isError() || status==SocketStatus.STOP) {
        return SocketState.CLOSED;
    } else if (!comet) {
        if (keepAlive) {
            inputBuffer.nextRequest();
            outputBuffer.nextRequest();
            return SocketState.OPEN;
        } else {
            return SocketState.CLOSED;
        }
    } else {
        return SocketState.LONG;
    }
}
 

@Override
public final SocketState event(SocketStatus status) throws IOException {
    return null;
}
 

@Override
public final SocketState asyncPostProcess() {
    return null;
}
 

@Override
public final SocketState asyncDispatch(SocketStatus status) {
    return null;
}
 

@Override
public final SocketState event(SocketStatus status) throws IOException {
    return null;
}
 

@Override
public final SocketState process(SocketWrapper<S> socketWrapper)
        throws IOException {
    return null;
}
 

public SocketState process(SocketWrapper<Long> socket,
SocketStatus status);