# Class AbstractProtocol<S>

java.lang.Object
org.apache.coyote.AbstractProtocol<S>

All Implemented Interfaces:
  `MBeanRegistration`, `ProtocolHandler`

Direct Known Subclasses:
  `AbstractAjpProtocol`, `AbstractHttp11Protocol`

public abstract class AbstractProtocol<S> extends Object implements ProtocolHandler, MBeanRegistration

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`protected static class`
`AbstractProtocol.ConnectionHandler<S>`
`protected static class`
`AbstractProtocol.RecycledProcessors`

## Field Summary

Fields
Modifier and Type
Field
Description
`protected Adapter`
`adapter`
The adapter provides the link between the ProtocolHandler and the connector.
`protected String`
`domain`
`protected MBeanServer`
`mserver`
`protected ObjectName`
`oname`
`protected int`
`processorCache`
The maximum number of idle processors that will be retained in the cache and re-used with a subsequent request.
`protected ObjectName`
`rgOname`
Name of MBean for the Global Request Processor.

## Constructor Summary

Constructors
Constructor
Description
`AbstractProtocol(AbstractEndpoint<S,?> endpoint)`

## Method Summary

Modifier and Type
Method
Description
`void`
`addWaitingProcessor(Processor processor)`
`long`
`awaitConnectionsClose(long waitMillis)`
Wait for the client connections to the server to close gracefully.
`void`
`closeServerSocketGraceful()`
Close the server socket (to prevent further connections) if the server socket was bound on `ProtocolHandler.start()` (rather than on `ProtocolHandler.init()`) but do not perform any further shutdown.
`protected abstract Processor`
`createProcessor()`
Create and configure a new Processor instance for the current protocol implementation.
`protected abstract Processor`
`createUpgradeProcessor(SocketWrapperBase<?> socket, UpgradeToken upgradeToken)`
`void`
`destroy()`
Destroy the protocol (optional).
`int`
`getAcceptCount()`
`int`
`getAcceptorThreadPriority()`
`Adapter`
`getAdapter()`
Return the adapter associated with the protocol handler.
`InetAddress`
`getAddress()`
`String`
`getClientCertProvider()`
When client certificate information is presented in a form other than instances of `X509Certificate` it needs to be converted before it can be used and this property controls which JSSE provider is used to perform the conversion.
`long`
`getConnectionCount()`
`int`
`getConnectionLinger()`
`int`
`getConnectionTimeout()`
`String`
`getDomain()`
`protected AbstractEndpoint<S,?>`
`getEndpoint()`
`Executor`
`getExecutor()`
The executor, provide access to the underlying thread pool.
`ObjectName`
`getGlobalRequestProcessorMBeanName()`
`AbstractEndpoint.Handler<S>`
`getHandler()`
`String`
`getId()`
The default behavior is to identify connectors uniquely with address and port.
`int`
`getKeepAliveTimeout()`
The time Tomcat will wait for a subsequent request before closing the connection.
`int`
`getLocalPort()`
`protected abstract Log`
`getLog()`
Concrete implementations need to provide access to their logger to be used by the abstract classes.
`int`
`getMaxConnections()`
`int`
`getMaxHeaderCount()`
`int`
`getMaxQueueSize()`
`int`
`getMaxThreads()`
`int`
`getMinSpareThreads()`
`String`
`getName()`
The name will be prefix-address-port if address is non-null and prefix-port if the address is null.
`int`
`getNameIndex()`
`protected abstract String`
`getNamePrefix()`
Obtain the prefix to be used when construction a name for this protocol handler.
`protected abstract UpgradeProtocol`
`getNegotiatedProtocol(String name)`
Find a suitable handler for the protocol negotiated at the network layer.
`ObjectName`
`getObjectName()`
`int`
`getPort()`
`int`
`getPortOffset()`
`int`
`getPortWithOffset()`
`int`
`getProcessorCache()`
`String`
`getProperty(String name)`
Generic property getter used by the digester.
`protected abstract String`
`getProtocolName()`
Obtain the name of the protocol, (Http, Ajp, etc.).
`boolean`
`getTcpNoDelay()`
`int`
`getThreadPriority()`
`protected abstract UpgradeProtocol`
`getUpgradeProtocol(String name)`
Find a suitable handler for the protocol upgraded name specified.
`ScheduledExecutorService`
`getUtilityExecutor()`
Get the utility executor that should be used by the protocol handler.
`int`
`getWaitingProcessorCount()`
`void`
`init()`
Initialise the protocol.
`boolean`
`isPaused()`
`boolean`
`isSendfileSupported()`
Does this ProtocolHandler support sendfile?
`void`
`pause()`
Pause the protocol (optional).
`void`
`postDeregister()`
`void`
`postRegister(Boolean registrationDone)`
`void`
`preDeregister()`
`ObjectName`
`preRegister(MBeanServer server, ObjectName name)`
`void`
`removeWaitingProcessor(Processor processor)`
`void`
`resume()`
Resume the protocol (optional).
`void`
`setAcceptCount(int acceptCount)`
`void`
`setAcceptorThreadPriority(int threadPriority)`
`void`
`setAdapter(Adapter adapter)`
The adapter, used to call the connector.
`void`
`setAddress(InetAddress ia)`
`void`
`setClientCertProvider(String s)`
`void`
`setConnectionLinger(int connectionLinger)`
`void`
`setConnectionTimeout(int timeout)`
`void`
`setExecutor(Executor executor)`
Set the optional executor that will be used by the connector.
`protected void`
`setHandler(AbstractEndpoint.Handler<S> handler)`
`void`
`setKeepAliveTimeout(int keepAliveTimeout)`
`void`
`setMaxConnections(int maxConnections)`
`void`
`setMaxHeaderCount(int maxHeaderCount)`
`void`
`setMaxQueueSize(int maxQueueSize)`
`void`
`setMaxThreads(int maxThreads)`
`void`
`setMinSpareThreads(int minSpareThreads)`
`void`
`setPort(int port)`
`void`
`setPortOffset(int portOffset)`
`void`
`setProcessorCache(int processorCache)`
`boolean`
`setProperty(String name, String value)`
Generic property setter used by the digester.
`void`
`setTcpNoDelay(boolean tcpNoDelay)`
`void`
`setThreadPriority(int threadPriority)`
`void`
`setUtilityExecutor(ScheduledExecutorService utilityExecutor)`
Set the utility executor that should be used by the protocol handler.
`void`
`start()`
Start the protocol.
`protected void`
`startAsyncTimeout()`
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.
`void`
`stop()`
Stop the protocol.
`protected void`
`stopAsyncTimeout()`

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

`addSslHostConfig, addSslHostConfig, addUpgradeProtocol, findSslHostConfigs, findUpgradeProtocols, getDesiredBufferSize`

## Field Details

### rgOname

protected ObjectName rgOname
Name of MBean for the Global Request Processor.

### adapter

protected Adapter adapter
The adapter provides the link between the ProtocolHandler and the connector.

### processorCache

protected int processorCache
The maximum number of idle processors that will be retained in the cache and re-used with a subsequent request. The default is 200. A value of -1 means unlimited. In the unlimited case, the theoretical maximum number of cached Processor objects is `getMaxConnections()` although it will usually be closer to `getMaxThreads()`.

### domain

protected String domain

### oname

protected ObjectName oname

### mserver

protected MBeanServer mserver

## Constructor Details

### AbstractProtocol

public AbstractProtocol(AbstractEndpoint<S,?> endpoint)

## Method Details

### setProperty

public boolean setProperty(String name, String value)
Generic property setter used by the digester. Other code should not need to use this. The digester will only use this method if it can't find a more specific setter. That means the property belongs to the Endpoint, the ServerSocketFactory or some other lower level component. This method ensures that it is visible to both.

Parameters:
  `name` - The name of the property to set
  `value` - The value, in string form, to set for the property
Returns:
  `true` if the property was set successfully, otherwise `false`

### getProperty

public String getProperty(String name)
Generic property getter used by the digester. Other code should not need to use this.

Parameters:
  `name` - The name of the property to get
Returns:
  The value of the property converted to a string

### getGlobalRequestProcessorMBeanName

public ObjectName getGlobalRequestProcessorMBeanName()

### setAdapter

public void setAdapter(Adapter adapter)
Description copied from interface: `ProtocolHandler`
The adapter, used to call the connector.

Specified by:
  `setAdapter` in interface `ProtocolHandler`
Parameters:
  `adapter` - The adapter to associate

### getAdapter

public Adapter getAdapter()
Description copied from interface: `ProtocolHandler`
Return the adapter associated with the protocol handler.

Specified by:
  `getAdapter` in interface `ProtocolHandler`
Returns:
  the adapter

### getProcessorCache

public int getProcessorCache()

### setProcessorCache

public void setProcessorCache(int processorCache)

### getClientCertProvider

public String getClientCertProvider()
When client certificate information is presented in a form other than instances of `X509Certificate` it needs to be converted before it can be used and this property controls which JSSE provider is used to perform the conversion. For example it is used with the AJP connectors and with the `SSLValve`. If not specified, the default provider will be used.

Returns:
  The name of the JSSE provider to use

### setClientCertProvider

public void setClientCertProvider(String s)

### getMaxHeaderCount

public int getMaxHeaderCount()

### setMaxHeaderCount

public void setMaxHeaderCount(int maxHeaderCount)

### isSendfileSupported

public boolean isSendfileSupported()
Description copied from interface: `ProtocolHandler`
Does this ProtocolHandler support sendfile?

Specified by:
  `isSendfileSupported` in interface `ProtocolHandler`
Returns:
  `true` if this Protocol Handler supports sendfile, otherwise `false`

### getId

public String getId()
Description copied from interface: `ProtocolHandler`
The default behavior is to identify connectors uniquely with address and port. However, certain connectors are not using that and need some other identifier, which then can be used as a replacement.

Specified by:
  `getId` in interface `ProtocolHandler`
Returns:
  the id

### getExecutor

public Executor getExecutor()
Description copied from interface: `ProtocolHandler`
The executor, provide access to the underlying thread pool.

Specified by:
  `getExecutor` in interface `ProtocolHandler`
Returns:
  The executor used to process requests

### setExecutor

public void setExecutor(Executor executor)
Description copied from interface: `ProtocolHandler`
Set the optional executor that will be used by the connector.

Specified by:
  `setExecutor` in interface `ProtocolHandler`
Parameters:
  `executor` - the executor

### getUtilityExecutor

public ScheduledExecutorService getUtilityExecutor()
Description copied from interface: `ProtocolHandler`
Get the utility executor that should be used by the protocol handler.

Specified by:
  `getUtilityExecutor` in interface `ProtocolHandler`
Returns:
  the executor

### setUtilityExecutor

public void setUtilityExecutor(ScheduledExecutorService utilityExecutor)
Description copied from interface: `ProtocolHandler`
Set the utility executor that should be used by the protocol handler.

Specified by:
  `setUtilityExecutor` in interface `ProtocolHandler`
Parameters:
  `utilityExecutor` - the executor

### getMaxThreads

public int getMaxThreads()

### setMaxThreads

public void setMaxThreads(int maxThreads)

### getMaxConnections

public int getMaxConnections()

### setMaxConnections

public void setMaxConnections(int maxConnections)

### getMinSpareThreads

public int getMinSpareThreads()

### setMinSpareThreads

public void setMinSpareThreads(int minSpareThreads)

### getThreadPriority

public int getThreadPriority()

### setThreadPriority

public void setThreadPriority(int threadPriority)

### getMaxQueueSize

public int getMaxQueueSize()

### setMaxQueueSize

public void setMaxQueueSize(int maxQueueSize)

### getAcceptCount

public int getAcceptCount()

### setAcceptCount

public void setAcceptCount(int acceptCount)

### getTcpNoDelay

public boolean getTcpNoDelay()

### setTcpNoDelay

public void setTcpNoDelay(boolean tcpNoDelay)

### getConnectionLinger

public int getConnectionLinger()

### setConnectionLinger

public void setConnectionLinger(int connectionLinger)

### getKeepAliveTimeout

public int getKeepAliveTimeout()
The time Tomcat will wait for a subsequent request before closing the connection. The default is `getConnectionTimeout()`.

Returns:
  The timeout in milliseconds

### setKeepAliveTimeout

public void setKeepAliveTimeout(int keepAliveTimeout)

### getAddress

public InetAddress getAddress()

### setAddress

public void setAddress(InetAddress ia)

### getPort

public int getPort()

### setPort

public void setPort(int port)

### getPortOffset

public int getPortOffset()

### setPortOffset

public void setPortOffset(int portOffset)

### getPortWithOffset

public int getPortWithOffset()

### getLocalPort

public int getLocalPort()

### getConnectionTimeout

public int getConnectionTimeout()

### setConnectionTimeout

public void setConnectionTimeout(int timeout)

### getConnectionCount

public long getConnectionCount()

### setAcceptorThreadPriority

public void setAcceptorThreadPriority(int threadPriority)

### getAcceptorThreadPriority

public int getAcceptorThreadPriority()

### getNameIndex

public int getNameIndex()

### getName

public String getName()
The name will be prefix-address-port if address is non-null and prefix-port if the address is null.

Returns:
  A name for this protocol instance that is appropriately quoted for use in an ObjectName.

### addWaitingProcessor

public void addWaitingProcessor(Processor processor)

### removeWaitingProcessor

public void removeWaitingProcessor(Processor processor)

### getWaitingProcessorCount

public int getWaitingProcessorCount()

### getEndpoint

protected AbstractEndpoint<S,?> getEndpoint()

### getHandler

public AbstractEndpoint.Handler<S> getHandler()

### setHandler

protected void setHandler(AbstractEndpoint.Handler<S> handler)

### getLog

protected abstract Log getLog()
Concrete implementations need to provide access to their logger to be used by the abstract classes.

Returns:
  the logger

### getNamePrefix

protected abstract String getNamePrefix()
Obtain the prefix to be used when construction a name for this protocol handler. The name will be prefix-address-port.

Returns:
  the prefix

### getProtocolName

protected abstract String getProtocolName()
Obtain the name of the protocol, (Http, Ajp, etc.). Used with JMX.

Returns:
  the protocol name

### getNegotiatedProtocol

protected abstract UpgradeProtocol getNegotiatedProtocol(String name)
Find a suitable handler for the protocol negotiated at the network layer.

Parameters:
  `name` - The name of the requested negotiated protocol.
Returns:
  The instance where `UpgradeProtocol.getAlpnName()` matches the requested protocol

### getUpgradeProtocol

protected abstract UpgradeProtocol getUpgradeProtocol(String name)
Find a suitable handler for the protocol upgraded name specified. This is used for direct connection protocol selection.

Parameters:
  `name` - The name of the requested negotiated protocol.
Returns:
  The instance where `UpgradeProtocol.getAlpnName()` matches the requested protocol

### createProcessor

protected abstract Processor createProcessor()
Create and configure a new Processor instance for the current protocol implementation.

Returns:
  A fully configured Processor instance that is ready to use

### createUpgradeProcessor

protected abstract Processor createUpgradeProcessor(SocketWrapperBase<?> socket, UpgradeToken upgradeToken)

### getObjectName

public ObjectName getObjectName()

### getDomain

public String getDomain()

### preRegister

public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception

Specified by:
  `preRegister` in interface `MBeanRegistration`
Throws:
  `Exception`

### postRegister

public void postRegister(Boolean registrationDone)

Specified by:
  `postRegister` in interface `MBeanRegistration`

### preDeregister

public void preDeregister() throws Exception

Specified by:
  `preDeregister` in interface `MBeanRegistration`
Throws:
  `Exception`

### postDeregister

public void postDeregister()

Specified by:
  `postDeregister` in interface `MBeanRegistration`

### init

public void init() throws Exception
Description copied from interface: `ProtocolHandler`
Initialise the protocol.

Specified by:
  `init` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to initialise

### start

public void start() throws Exception
Description copied from interface: `ProtocolHandler`
Start the protocol.

Specified by:
  `start` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to start

### startAsyncTimeout

protected void startAsyncTimeout()
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.

### stopAsyncTimeout

protected void stopAsyncTimeout()

### pause

public void pause() throws Exception
Description copied from interface: `ProtocolHandler`
Pause the protocol (optional).

Specified by:
  `pause` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to pause

### isPaused

public boolean isPaused()

### resume

public void resume() throws Exception
Description copied from interface: `ProtocolHandler`
Resume the protocol (optional).

Specified by:
  `resume` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to resume

### stop

public void stop() throws Exception
Description copied from interface: `ProtocolHandler`
Stop the protocol.

Specified by:
  `stop` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to stop

### destroy

public void destroy() throws Exception
Description copied from interface: `ProtocolHandler`
Destroy the protocol (optional).

Specified by:
  `destroy` in interface `ProtocolHandler`
Throws:
  `Exception` - If the protocol handler fails to destroy

### closeServerSocketGraceful

public void closeServerSocketGraceful()
Description copied from interface: `ProtocolHandler`
Close the server socket (to prevent further connections) if the server socket was bound on `ProtocolHandler.start()` (rather than on `ProtocolHandler.init()`) but do not perform any further shutdown.

Specified by:
  `closeServerSocketGraceful` in interface `ProtocolHandler`

### awaitConnectionsClose

public long awaitConnectionsClose(long waitMillis)
Description copied from interface: `ProtocolHandler`
Wait for the client connections to the server to close gracefully. The method will return when all of the client connections have closed or the method has been waiting for `waitTimeMillis`.

Specified by:
  `awaitConnectionsClose` in interface `ProtocolHandler`
Parameters:
  `waitMillis` - The maximum time to wait in milliseconds for the client connections to close.
Returns:
  The wait time, if any remaining when the method returned