org.apache.coyote

Class AbstractProcessorLight

java.lang.Object

org.apache.coyote.AbstractProcessorLight

All Implemented Interfaces:

Processor

Direct Known Subclasses:

AbstractProcessor, UpgradeProcessorBase

public abstract class AbstractProcessorLight
extends Object
implements Processor

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.

Constructor Summary

Constructors

Constructor and Description
AbstractProcessorLight()

Method Summary

Modifier and Type	Method and Description
void	addDispatch(DispatchType dispatchType)
protected abstract AbstractEndpoint.Handler.SocketState	asyncPostProcess()
protected void	clearDispatches()
protected abstract AbstractEndpoint.Handler.SocketState	dispatch(SocketEvent status) Process an in-progress request that is not longer in standard HTTP mode.
Iterator<DispatchType>	getIteratorAndClearDispatches()
protected abstract Log	getLog()
AbstractEndpoint.Handler.SocketState	process(SocketWrapperBase<?> socketWrapper, SocketEvent status) Process a connection.
protected abstract AbstractEndpoint.Handler.SocketState	service(SocketWrapperBase<?> socketWrapper) Service a 'standard' HTTP request.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.apache.coyote.Processor

getLeftoverInput, getRequest, getUpgradeToken, isAsync, isUpgrade, pause, recycle, setSslSupport, timeoutAsync

Constructor Detail

AbstractProcessorLight

public AbstractProcessorLight()

Method Detail

process

public AbstractEndpoint.Handler.SocketState process(SocketWrapperBase<?> socketWrapper,
                                                    SocketEvent status)
                                             throws IOException

Description copied from interface: Processor

Process a connection. This is called whenever an event occurs (e.g. more data arrives) that allows processing to continue for a connection that is not currently being processed.

Specified by:

process in interface Processor

Parameters:

socketWrapper - The connection to process

status - The status of the connection that triggered this additional processing

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

addDispatch

public void addDispatch(DispatchType dispatchType)

getIteratorAndClearDispatches

public Iterator<DispatchType> getIteratorAndClearDispatches()

clearDispatches

protected void clearDispatches()

service

protected abstract AbstractEndpoint.Handler.SocketState service(SocketWrapperBase<?> socketWrapper)
                                                         throws IOException

Service a 'standard' HTTP request. This method is called for both new requests and for requests that have partially read the HTTP request line or HTTP headers. Once the headers have been fully read this method is not called again until there is a new HTTP request to process. Note that the request type may change during processing which may result in one or more calls to dispatch(SocketEvent). Requests may be pipe-lined.

Parameters:

socketWrapper - The connection 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

dispatch

protected abstract AbstractEndpoint.Handler.SocketState dispatch(SocketEvent status)

Process an in-progress request that is not 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.

Parameters:

status - The event to process

Returns:

the socket state

asyncPostProcess

protected abstract AbstractEndpoint.Handler.SocketState asyncPostProcess()

getLog

protected abstract Log getLog()