AbstractProcessor (Apache Tomcat 9.0.111 API Documentation)
Description: declaration: package: org.apache.coyote, class: AbstractProcessor

# Class AbstractProcessor

java.lang.Object
org.apache.coyote.AbstractProcessorLight
org.apache.coyote.AbstractProcessor

All Implemented Interfaces:
  `ActionHook, Processor`

Direct Known Subclasses:
  `AjpProcessor, Http11Processor`

public abstract class AbstractProcessor extends AbstractProcessorLight implements ActionHook
Provides functionality and attributes common to all supported protocols (currently HTTP and AJP) for processing a single request/response.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected final Adapter`
  `adapter`
  `protected final org.apache.coyote.AsyncStateMachine`
  `asyncStateMachine`
  `protected final Request`
  `request`
  `protected final Response`
  `response`
  `protected SocketWrapperBase<?>`
  `socketWrapper`
  `protected SSLSupport`
  `sslSupport`
  `protected final UserDataHelper`
  `userDataHelper`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  ``
  `AbstractProcessor(Adapter adapter)`
  `protected`
  `AbstractProcessor(Adapter adapter, Request coyoteRequest, Response coyoteResponse)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected void`
  `ack()`
  Deprecated.
  Unused.
  `protected abstract void`
  `ack(ContinueResponseTiming continueResponseTiming)`
  Process acknowledgment of the request.
  `final void`
  `action(ActionCode actionCode, Object param)`
  Send an action to the connector.
  `AbstractEndpoint.Handler.SocketState`
  `asyncPostProcess()`
  Calls the post process of the async state machine.
  `protected abstract int`
  `available(boolean doRead)`
  Queries if bytes are available in buffers.
  `boolean`
  `checkAsyncTimeoutGeneration()`
  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.
  `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.
  `final AbstractEndpoint.Handler.SocketState`
  `dispatch(SocketEvent status)`
  Process an in-progress request that is no longer in standard HTTP mode.
  `protected abstract AbstractEndpoint.Handler.SocketState`
  `dispatchEndRequest()`
  Perform any necessary clean-up processing if the dispatch resulted in the completion of processing for the current request.
  `protected void`
  `dispatchNonBlockingRead()`
  Perform any necessary processing for a non-blocking read before dispatching to the adapter.
  `protected void`
  `doHttpUpgrade(UpgradeToken upgradeToken)`
  Process an HTTP upgrade.
  `protected void`
  `doPush(Request pushTarget)`
  Process a push.
  `protected abstract void`
  `earlyHints()`
  `protected void`
  `execute(Runnable runnable)`
  Provides a mechanism to trigger processing on a container thread.
  `protected void`
  `executeDispatches()`
  `protected abstract void`
  `finishResponse()`
  Finish the current response.
  `protected abstract void`
  `flush()`
  Callback to write data from the buffer.
  `protected abstract boolean`
  `flushBufferedWrite()`
  Flush any pending writes.
  `Adapter`
  `getAdapter()`
  Get the associated adapter.
  `long`
  `getAsyncTimeout()`
  `protected Object`
  `getConnectionID()`
  Protocols that support multiplexing (e.g.
  `protected ErrorState`
  `getErrorState()`
  `ByteBuffer`
  `getLeftoverInput()`
  Allows retrieving additional input during the upgrade process.
  `protected boolean`
  `getPopulateRequestAttributesFromSocket()`
  Processors that populate request attributes directly (e.g.
  `Request`
  `getRequest()`
  `protected final SocketWrapperBase<?>`
  `getSocketWrapper()`
  `protected Object`
  `getStreamID()`
  Protocols that support multiplexing (e.g.
  `UpgradeToken`
  `getUpgradeToken()`
  Generate an upgrade token.
  `boolean`
  `isAsync()`
  `protected boolean`
  `isPushSupported()`
  Protocols that support push should override this method and return `true`.
  `protected boolean`
  `isReadyForRead()`
  `protected abstract boolean`
  `isReadyForWrite()`
  `protected abstract boolean`
  `isRequestBodyFullyRead()`
  `protected abstract boolean`
  `isTrailerFieldsReady()`
  `protected boolean`
  `isTrailerFieldsSupported()`
  Protocols that support trailer fields should override this method and return `true`.
  `boolean`
  `isUpgrade()`
  Processors that implement HTTP upgrade must override this method.
  `protected final void`
  `logAccess(SocketWrapperBase<?> socketWrapper)`
  Add an entry to the access log for a failed connection attempt.
  `protected void`
  `parseHost(MessageBytes valueMB)`
  `protected void`
  `populateHost()`
  Called when a host header is not present in the request (e.g.
  `protected void`
  `populatePort()`
  Called when a host header is not present or is empty in the request (e.g.
  `protected void`
  `populateRequestAttributeRemoteHost()`
  Populate the remote host request attribute.
  `protected void`
  `populateSslRequestAttributes()`
  Populate the TLS related request attributes from the `SSLSupport` instance associated with this processor.
  `protected abstract void`
  `prepareResponse()`
  When committing the response, we have to validate the set of headers, as well as set up the response filters.
  `protected void`
  `processSocketEvent(SocketEvent event, boolean dispatch)`
  `void`
  `recycle()`
  Recycle the processor, ready for the next request which may be on the same connection or a different connection.
  `protected abstract void`
  `registerReadInterest()`
  When using non blocking IO, register to get a callback when polling determines that bytes are available for reading.
  `void`
  `setAsyncTimeout(long timeout)`
  `protected void`
  `setErrorState(ErrorState errorState, 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.
  `protected abstract void`
  `setRequestBody(ByteChunk body)`
  Set the specified byte chunk as the request body that will be read.
  `protected void`
  `setSocketWrapper(SocketWrapperBase<?> socketWrapper)`
  Set the socket wrapper being used.
  `final void`
  `setSslSupport(SSLSupport sslSupport)`
  Set the SSL information for this HTTP connection.
  `protected abstract void`
  `setSwallowResponse()`
  The response is finished and no additional bytes need to be sent to the client.
  `protected void`
  `sslReHandShake()`
  Processors that can perform a TLS re-handshake (e.g.
  `void`
  `timeoutAsync(long now)`
  Check this processor to see if the timeout has expired and process a timeout if that is that case.

  ### Methods inherited from class AbstractProcessorLight

  `addDispatch, clearDispatches, getIteratorAndClearDispatches, getLog, process, service`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface Processor

  `pause`

- ## Field Details

  - ### adapter

    protected final Adapter adapter

  - ### asyncStateMachine

    protected final org.apache.coyote.AsyncStateMachine asyncStateMachine

  - ### request

    protected final Request request

  - ### response

    protected final Response response

  - ### socketWrapper

    protected volatile SocketWrapperBase<?> socketWrapper

  - ### sslSupport

    protected volatile SSLSupport sslSupport

  - ### userDataHelper

    protected final UserDataHelper userDataHelper

- ## Constructor Details

  - ### AbstractProcessor

    public AbstractProcessor(Adapter adapter)

  - ### AbstractProcessor

    protected AbstractProcessor(Adapter adapter, Request coyoteRequest, Response coyoteResponse)

- ## Method Details

  - ### setErrorState

    protected void setErrorState(ErrorState errorState, 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()

  - ### getRequest

    public Request getRequest()
    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()
    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(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()
    Specified by:
      `isAsync` in interface `Processor`
    Returns:
      `true` if the Processor state is async, otherwise `false`

  - ### asyncPostProcess

    public AbstractEndpoint.Handler.SocketState asyncPostProcess()
    Description copied from class: `AbstractProcessorLight`
    Calls the post process of the async state machine.
    Specified by:
      `asyncPostProcess` in class `AbstractProcessorLight`
    Returns:
      The state the caller should put the socket in when this method returns

  - ### dispatch

    public final AbstractEndpoint.Handler.SocketState dispatch(SocketEvent status) throws 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:
      `IOException` - If an I/O error occurs during the processing of the request

  - ### parseHost

    protected void parseHost(MessageBytes valueMB)

  - ### 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, 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)

  - ### getAsyncTimeout

    public long getAsyncTimeout()

  - ### 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 IOException
    When committing the response, we have to validate the set of headers, as well as set up the response filters.
    Throws:
      `IOException` - IO exception during commit

  - ### finishResponse

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

  - ### ack

    @Deprecated protected void ack()
    Deprecated.
    Unused. This will be removed in Tomcat 10 onwards. Use `ack(ContinueResponseTiming)`.

  - ### 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 IOException
    Throws:
      `IOException`

  - ### flush

    protected abstract void flush() throws IOException
    Callback to write data from the buffer.
    Throws:
      `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 IOException
    Processors that can perform a TLS re-handshake (e.g. HTTP/1.1) should override this method and implement the re-handshake.
    Throws:
      `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)

  - ### isReadyForRead

    protected boolean isReadyForRead()

  - ### isRequestBodyFullyRead

    protected abstract boolean isRequestBodyFullyRead()
    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()
    Returns:
      `true` if bytes can be written without blocking

  - ### executeDispatches

    protected void executeDispatches()

  - ### 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:
      `UnsupportedOperationException` - if the protocol does not support HTTP upgrade

  - ### getLeftoverInput

    public 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()
    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:
      `UnsupportedOperationException` - if the protocol does not support push

  - ### isTrailerFieldsReady

    protected abstract boolean isTrailerFieldsReady()

  - ### 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`.

  - ### getConnectionID

    protected Object getConnectionID()
    Protocols that support multiplexing (e.g. HTTP/2) should override this method and return the appropriate ID.
    Returns:
      The stream ID associated with this request or `null` if a multiplexing protocol is not being used

  - ### getStreamID

    protected Object getStreamID()
    Protocols that support multiplexing (e.g. HTTP/2) should override this method and return the appropriate ID.
    Returns:
      The stream ID associated with this request or `null` if a multiplexing protocol is not being used

  - ### flushBufferedWrite

    protected abstract boolean flushBufferedWrite() throws 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:
      `IOException` - If an I/O error occurs while attempting to flush the data

  - ### dispatchEndRequest

    protected abstract AbstractEndpoint.Handler.SocketState dispatchEndRequest() throws 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:
      `IOException` - If an I/O error occurs while attempting to end the request

  - ### logAccess

    protected final void logAccess(SocketWrapperBase<?> socketWrapper) throws 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:
      `IOException` - If an I/O error occurs during the processing of the request