Package org.apache.coyote

Class AbstractProcessor

    • Field Detail

      • adapter

        protected final Adapter adapter
        The adapter for this processor.

      • asyncStateMachine

        protected final org.apache.coyote.AsyncStateMachine asyncStateMachine
        State machine for async processing.

      • request

        protected final Request request
        The request being processed.

      • response

        protected final Response response
        The response being processed.

      • socketWrapper

        protected volatile SocketWrapperBase<?> socketWrapper
        The socket wrapper for this processor.

      • sslSupport

        protected volatile SSLSupport sslSupport
        SSL support for this connection.

      • userDataHelper

        protected final UserDataHelper userDataHelper
        User data helper for logging.

    • Constructor Detail

      • AbstractProcessor

        public AbstractProcessor​(Adapter adapter)
        Creates a new processor with the given adapter.
        Parameters:
        adapter - The adapter for this processor

      • AbstractProcessor

        protected AbstractProcessor​(Adapter adapter,
                            Request coyoteRequest,
                            Response coyoteResponse)
        Constructs a new processor with the given adapter, request, and response.
        Parameters:
        adapter - The adapter for this processor
        coyoteRequest - The coyote request
        coyoteResponse - The coyote response

    • Method Detail

      • setErrorState

        protected void setErrorState​(ErrorState errorState,
                             java.lang.Throwable t)
        Update the current error state to the new error state if the new error state is more severe than the current error state.
        Parameters:
        errorState - The error status details
        t - The error which occurred

      • getErrorState

        protected ErrorState getErrorState()
        Gets the current error state.
        Returns:
        the current error state

      • getRequest

        public Request getRequest()
        Description copied from interface: Processor
        Gets the request associated with this processor.
        Specified by:
        getRequest in interface Processor
        Returns:
        The request associated with this processor.

      • getAdapter

        public Adapter getAdapter()
        Get the associated adapter.
        Returns:
        the associated adapter

      • setSocketWrapper

        protected void setSocketWrapper​(SocketWrapperBase<?> socketWrapper)
        Set the socket wrapper being used.
        Parameters:
        socketWrapper - The socket wrapper

      • getSocketWrapper

        protected final SocketWrapperBase<?> getSocketWrapper()
        Get the socket wrapper being used.
        Returns:
        the socket wrapper being used.

      • setSslSupport

        public final void setSslSupport​(SSLSupport sslSupport)
        Description copied from interface: Processor
        Set the SSL information for this HTTP connection.
        Specified by:
        setSslSupport in interface Processor
        Parameters:
        sslSupport - The SSL support object to use for this connection

      • execute

        protected void execute​(java.lang.Runnable runnable)
        Provides a mechanism to trigger processing on a container thread.
        Parameters:
        runnable - The task representing the processing that needs to take place on a container thread

      • isAsync

        public boolean isAsync()
        Description copied from interface: Processor
        Checks if the Processor is in async state.
        Specified by:
        isAsync in interface Processor
        Returns:
        true if the Processor state is async, otherwise false

      • dispatch

        public final AbstractEndpoint.Handler.SocketState dispatch​(SocketEvent status)
                                                    throws java.io.IOException
        Description copied from class: AbstractProcessorLight
        Process an in-progress request that is no longer in standard HTTP mode. Uses currently include Servlet 3.0 Async and HTTP upgrade connections. Further uses may be added in the future. These will typically start as HTTP requests.
        Specified by:
        dispatch in class AbstractProcessorLight
        Parameters:
        status - The event to process
        Returns:
        The state the caller should put the socket in when this method returns
        Throws:
        java.io.IOException - If an I/O error occurs during the processing of the request

      • parseHost

        protected void parseHost​(MessageBytes valueMB)
        Parses the Host header value and populates the server name and port.
        Parameters:
        valueMB - The MessageBytes containing the Host header value

      • populateHost

        protected void populateHost()
        Called when a host header is not present in the request (e.g. HTTP/1.0). It populates the server name with appropriate information. The source is expected to vary by protocol.

        The default implementation is a NO-OP.

      • populatePort

        protected void populatePort()
        Called when a host header is not present or is empty in the request (e.g. HTTP/1.0). It populates the server port with appropriate information. The source is expected to vary by protocol.

        The default implementation is a NO-OP.

      • action

        public final void action​(ActionCode actionCode,
                         java.lang.Object param)
        Description copied from interface: ActionHook
        Send an action to the connector.
        Specified by:
        action in interface ActionHook
        Parameters:
        actionCode - Type of the action
        param - Action parameter

      • dispatchNonBlockingRead

        protected void dispatchNonBlockingRead()
        Perform any necessary processing for a non-blocking read before dispatching to the adapter.

      • timeoutAsync

        public void timeoutAsync​(long now)
        Check this processor to see if the timeout has expired and process a timeout if that is that case.

        Note: The name of this method originated with the Servlet 3.0 asynchronous processing but evolved over time to represent a timeout that is triggered independently of the socket read/write timeouts.

        Subclasses of this base class represent a single request/response pair. The timeout to be processed is, therefore, the Servlet asynchronous processing timeout.

        Specified by:
        timeoutAsync in interface Processor
        Parameters:
        now - The time (as returned by System.currentTimeMillis()) to use as the current time to determine whether the timeout has expired. If negative, the timeout will always be treated as if it has expired.

      • checkAsyncTimeoutGeneration

        public boolean checkAsyncTimeoutGeneration()
        Description copied from interface: Processor
        Check to see if the async generation (each cycle of async increments the generation of the AsyncStateMachine) is the same as the generation when the most recent async timeout was triggered. This is intended to be used to avoid unnecessary processing.
        Specified by:
        checkAsyncTimeoutGeneration in interface Processor
        Returns:
        true If the async generation has not changed since the async timeout was triggered

      • setAsyncTimeout

        public void setAsyncTimeout​(long timeout)
        Sets the async timeout.
        Parameters:
        timeout - The timeout in milliseconds

      • getAsyncTimeout

        public long getAsyncTimeout()
        Gets the async timeout.
        Returns:
        the async timeout in milliseconds

      • recycle

        public void recycle()
        Description copied from interface: Processor
        Recycle the processor, ready for the next request which may be on the same connection or a different connection.
        Specified by:
        recycle in interface Processor

      • prepareResponse

        protected abstract void prepareResponse()
                                 throws java.io.IOException
        When committing the response, we have to validate the set of headers, as well as set up the response filters.
        Throws:
        java.io.IOException - IO exception during commit

      • finishResponse

        protected abstract void finishResponse()
                                throws java.io.IOException
        Finish the current response.
        Throws:
        java.io.IOException - IO exception during the write

      • ack

        protected abstract void ack​(ContinueResponseTiming continueResponseTiming)
        Process acknowledgment of the request.
        Parameters:
        continueResponseTiming - specifies when an acknowledgment should be sent

      • earlyHints

        protected abstract void earlyHints()
                            throws java.io.IOException
        Process early hints (103 Early Hints).
        Throws:
        java.io.IOException - IO exception during processing

      • flush

        protected abstract void flush()
                       throws java.io.IOException
        Callback to write data from the buffer.
        Throws:
        java.io.IOException - IO exception during the write

      • available

        protected abstract int available​(boolean doRead)
        Queries if bytes are available in buffers.
        Parameters:
        doRead - true to perform a read when no bytes are availble
        Returns:
        the amount of bytes that are known to be available

      • setRequestBody

        protected abstract void setRequestBody​(ByteChunk body)
        Set the specified byte chunk as the request body that will be read. This allows saving and processing requests.
        Parameters:
        body - the byte chunk containing all the request bytes

      • setSwallowResponse

        protected abstract void setSwallowResponse()
        The response is finished and no additional bytes need to be sent to the client.

      • disableSwallowRequest

        protected abstract void disableSwallowRequest()
        Swallowing bytes is required for pipelining requests, so this allows to avoid doing extra operations in case an error occurs and the connection is to be closed instead.

      • getPopulateRequestAttributesFromSocket

        protected boolean getPopulateRequestAttributesFromSocket()
        Processors that populate request attributes directly (e.g. AJP) should over-ride this method and return false.
        Returns:
        true if the SocketWrapper should be used to populate the request attributes, otherwise false.

      • populateRequestAttributeRemoteHost

        protected void populateRequestAttributeRemoteHost()
        Populate the remote host request attribute. Processors (e.g. AJP) that populate this from an alternative source should override this method.

      • populateSslRequestAttributes

        protected void populateSslRequestAttributes()
        Populate the TLS related request attributes from the SSLSupport instance associated with this processor. Protocols that populate TLS attributes from a different source (e.g. AJP) should override this method.

      • sslReHandShake

        protected void sslReHandShake()
                       throws java.io.IOException
        Processors that can perform a TLS re-handshake (e.g. HTTP/1.1) should override this method and implement the re-handshake.
        Throws:
        java.io.IOException - If authentication is required then there will be I/O with the client and this exception will be thrown if that goes wrong

      • processSocketEvent

        protected void processSocketEvent​(SocketEvent event,
                                  boolean dispatch)
        Processes a socket event.
        Parameters:
        event - The socket event to process
        dispatch - true to dispatch to a container thread

      • isReadyForRead

        protected boolean isReadyForRead()
        Checks if the processor is ready for reading.
        Returns:
        true if there is data available or read interest is registered

      • isRequestBodyFullyRead

        protected abstract boolean isRequestBodyFullyRead()
        Checks if the request body has been fully read.
        Returns:
        true if it is known that the request body has been fully read

      • registerReadInterest

        protected abstract void registerReadInterest()
        When using non blocking IO, register to get a callback when polling determines that bytes are available for reading.

      • isReadyForWrite

        protected abstract boolean isReadyForWrite()
        Checks if the processor is ready for writing.
        Returns:
        true if bytes can be written without blocking

      • executeDispatches

        protected void executeDispatches()
        Executes any pending non-blocking dispatches.

      • getUpgradeToken

        public UpgradeToken getUpgradeToken()
        Generate an upgrade token. Processors that implement HTTP upgrade must override this method and provide the necessary token.
        Specified by:
        getUpgradeToken in interface Processor
        Returns:
        An upgrade token encapsulating the information required to process the upgrade request

      • doHttpUpgrade

        protected void doHttpUpgrade​(UpgradeToken upgradeToken)
        Process an HTTP upgrade. Processors that support HTTP upgrade should override this method and process the provided token.
        Parameters:
        upgradeToken - Contains all the information necessary for the Processor to process the upgrade
        Throws:
        java.lang.UnsupportedOperationException - if the protocol does not support HTTP upgrade

      • getLeftoverInput

        public java.nio.ByteBuffer getLeftoverInput()
        Allows retrieving additional input during the upgrade process. Processors that implement HTTP upgrade must override this method.
        Specified by:
        getLeftoverInput in interface Processor
        Returns:
        leftover bytes

      • isUpgrade

        public boolean isUpgrade()
        Checks if the Processor is processing an upgrade request. Processors that implement HTTP upgrade must override this method.
        Specified by:
        isUpgrade in interface Processor
        Returns:
        true if the Processor is currently processing an upgrade request, otherwise false

      • isPushSupported

        protected boolean isPushSupported()
        Protocols that support push should override this method and return true.
        Returns:
        true if push is supported by this processor, otherwise false.

      • doPush

        protected void doPush​(Request pushTarget)
        Process a push. Processors that support push should override this method and process the provided token.
        Parameters:
        pushTarget - Contains all the information necessary for the Processor to process the push request
        Throws:
        java.lang.UnsupportedOperationException - if the protocol does not support push

      • isTrailerFieldsReady

        protected abstract boolean isTrailerFieldsReady()
        Checks if trailer fields are ready.
        Returns:
        true if trailer fields are ready

      • isTrailerFieldsSupported

        protected boolean isTrailerFieldsSupported()
        Protocols that support trailer fields should override this method and return true.
        Returns:
        true if trailer fields are supported by this processor, otherwise false.

      • getProtocolRequestId

        protected java.lang.Object getProtocolRequestId()
        Protocols that provide per HTTP request IDs (e.g. Stream ID for HTTP/2) should override this method and return the appropriate ID.
        Returns:
        The ID associated with this request or the empty string if no such ID is defined

      • getServletConnection

        protected abstract ServletConnection getServletConnection()
        Protocols must override this method and return an appropriate ServletConnection instance
        Returns:
        the ServletConnection instance associated with the current request.

      • flushBufferedWrite

        protected abstract boolean flushBufferedWrite()
                                       throws java.io.IOException
        Flush any pending writes. Used during non-blocking writes to flush any remaining data from a previous incomplete write.
        Returns:
        true if data remains to be flushed at the end of method
        Throws:
        java.io.IOException - If an I/O error occurs while attempting to flush the data

      • dispatchEndRequest

        protected abstract AbstractEndpoint.Handler.SocketState dispatchEndRequest()
                                                                    throws java.io.IOException
        Perform any necessary clean-up processing if the dispatch resulted in the completion of processing for the current request.
        Returns:
        The state to return for the socket once the clean-up for the current request has completed
        Throws:
        java.io.IOException - If an I/O error occurs while attempting to end the request

      • logAccess

        protected final void logAccess​(SocketWrapperBase<?> socketWrapper)
                        throws java.io.IOException
        Description copied from class: AbstractProcessorLight
        Add an entry to the access log for a failed connection attempt.
        Overrides:
        logAccess in class AbstractProcessorLight
        Parameters:
        socketWrapper - The connection to process
        Throws:
        java.io.IOException - If an I/O error occurs during the processing of the request