Package org.apache.tomcat.util.net

## Class AbstractEndpoint<S,​U>

- java.lang.Object
- - org.apache.tomcat.util.net.AbstractEndpoint<S,​U>

- Type Parameters:
    `S` - The type used by the socket wrapper associated with this endpoint. May be the same as U.
    `U` - The type of the underlying socket used by this endpoint. May be the same as S.
  Direct Known Subclasses:
    `AbstractJsseEndpoint`, `AprEndpoint`

      public abstract class AbstractEndpoint<S,​U>
      extends java.lang.Object

  Author:
    Mladen Turk, Remy Maucherat

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `protected static class` | `AbstractEndpoint.BindState` |
    `static interface` | `AbstractEndpoint.Handler<S>` |

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected Acceptor<U>` | `acceptor` | Thread used to accept new connections and pass them to worker threads.
    `protected int` | `acceptorThreadCount` | Deprecated. This attribute is hard-coded to `1` and is no longer configurable.
    `protected int` | `acceptorThreadPriority` | Priority of the acceptor threads.
    `protected java.util.HashMap<java.lang.String,​java.lang.Object>` | `attributes` | Attributes provide a way for configuration to be passed to sub-components without the `ProtocolHandler` being aware of the properties available on those sub-components.
    `protected java.util.Map<U,​SocketWrapperBase<S>>` | `connections` | Map holding all current connections keyed with the sockets.
    `protected boolean` | `internalExecutor` | Are we using an internal executor
    `protected java.util.List<java.lang.String>` | `negotiableProtocols` |
    `protected boolean` | `paused` | Will be set to true whenever the endpoint is paused.
    `protected SynchronizedStack<SocketProcessorBase<S>>` | `processorCache` | Cache for SocketProcessor objects
    `protected boolean` | `running` | Running state of the endpoint.
    `protected static StringManager` | `sm` |
    `protected SocketProperties` | `socketProperties` | Socket properties
    `protected java.util.concurrent.ConcurrentMap<java.lang.String,​SSLHostConfig>` | `sslHostConfigs` |
    `protected int` | `threadPriority` | Priority of the worker threads.

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AbstractEndpoint()` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addNegotiatedProtocol​(java.lang.String negotiableProtocol)` |
    `void` | `addSslHostConfig​(SSLHostConfig sslHostConfig)` | Add the given SSL Host configuration.
    `void` | `addSslHostConfig​(SSLHostConfig sslHostConfig, boolean replace)` | Add the given SSL Host configuration, optionally replacing the existing configuration for the given host.
    `long` | `awaitConnectionsClose​(long waitMillis)` | Wait for the client connections to the server to close gracefully.
    `abstract void` | `bind()` |
    `void` | `closeServerSocketGraceful()` | Close the server socket (to prevent further connections) if the server socket was originally bound on `start()` (rather than on `init()`).
    `protected void` | `closeSocket​(U socket)` | Close the socket when the connection has to be immediately closed when an error occurs while configuring the accepted socket or trying to dispatch it for processing.
    `protected long` | `countDownConnection()` |
    `protected void` | `countUpOrAwaitConnection()` |
    `void` | `createExecutor()` |
    `protected abstract SocketProcessorBase<S>` | `createSocketProcessor​(SocketWrapperBase<S> socketWrapper, SocketEvent event)` |
    `protected abstract void` | `createSSLContext​(SSLHostConfig sslHostConfig)` | Create the SSLContext for the given SSLHostConfig.
    `void` | `destroy()` |
    `protected abstract void` | `destroySocket​(U socket)` | Close the socket.
    `protected void` | `destroySsl()` |
    `protected abstract void` | `doCloseServerSocket()` | Actually close the server socket but don't perform any other clean-up.
    `SSLHostConfig[]` | `findSslHostConfigs()` |
    `int` | `getAcceptCount()` |
    `int` | `getAcceptorThreadPriority()` |
    `java.net.InetAddress` | `getAddress()` |
    `java.lang.Object` | `getAttribute​(java.lang.String key)` | Used by sub-components to retrieve configuration information.
    `boolean` | `getBindOnInit()` |
    `protected AbstractEndpoint.BindState` | `getBindState()` |
    `long` | `getConnectionCount()` | Return the current count of connections handled by this endpoint, if the connections are counted (which happens when the maximum count of connections is limited), or `-1` if they are not.
    `int` | `getConnectionLinger()` | Socket linger.
    `java.util.Set<SocketWrapperBase<S>>` | `getConnections()` | Get a set with the current open connections.
    `int` | `getConnectionTimeout()` | Socket timeout.
    `int` | `getCurrentThreadCount()` | Return the amount of threads that are managed by the pool.
    `int` | `getCurrentThreadsBusy()` | Return the amount of threads that are in use
    `boolean` | `getDaemon()` |
    `java.lang.String` | `getDefaultSSLHostConfigName()` |
    `protected boolean` | `getDeferAccept()` |
    `java.lang.String` | `getDomain()` |
    `java.util.concurrent.Executor` | `getExecutor()` |
    `long` | `getExecutorTerminationTimeoutMillis()` |
    `AbstractEndpoint.Handler<S>` | `getHandler()` |
    `java.lang.String` | `getId()` | The default behavior is to identify connectors uniquely with address and port.
    `int` | `getKeepAliveTimeout()` |
    `protected abstract java.net.InetSocketAddress` | `getLocalAddress()` | Obtain the network address the server socket is bound to.
    `int` | `getLocalPort()` |
    `protected abstract Log` | `getLog()` |
    `int` | `getMaxConnections()` |
    `int` | `getMaxKeepAliveRequests()` |
    `int` | `getMaxThreads()` |
    `int` | `getMinSpareThreads()` |
    `java.lang.String` | `getName()` |
    `int` | `getPort()` |
    `int` | `getPortOffset()` |
    `int` | `getPortWithOffset()` |
    `java.lang.String` | `getProperty​(java.lang.String name)` |
    `SocketProperties` | `getSocketProperties()` |
    `protected SSLHostConfig` | `getSSLHostConfig​(java.lang.String sniHostName)` | Look up the SSLHostConfig for the given host name.
    `boolean` | `getTcpNoDelay()` | Socket TCP no delay.
    `int` | `getThreadPriority()` |
    `boolean` | `getUseAsyncIO()` |
    `boolean` | `getUseSendfile()` |
    `java.util.concurrent.ScheduledExecutorService` | `getUtilityExecutor()` |
    `boolean` | `hasNegotiableProtocols()` |
    `void` | `init()` |
    `protected LimitLatch` | `initializeConnectionLatch()` |
    `abstract boolean` | `isAlpnSupported()` | Identifies if the endpoint supports ALPN.
    `boolean` | `isPaused()` |
    `boolean` | `isRunning()` |
    `boolean` | `isSSLEnabled()` |
    `void` | `pause()` | Pause the endpoint, which will stop it accepting new connections and unlock the acceptor.
    `boolean` | `processSocket​(SocketWrapperBase<S> socketWrapper, SocketEvent event, boolean dispatch)` | Process the given SocketWrapper with the given status.
    `protected void` | `releaseSSLContext​(SSLHostConfig sslHostConfig)` | Release the SSLContext, if any, associated with the SSLHostConfig.
    `void` | `reloadSslHostConfig​(java.lang.String hostName)` | Re-read the configuration files for the SSL host and replace the existing SSL configuration with the updated settings.
    `void` | `reloadSslHostConfigs()` | Re-read the configuration files for all SSL hosts and replace the existing SSL configuration with the updated settings.
    `SSLHostConfig` | `removeSslHostConfig​(java.lang.String hostName)` | Removes the SSL host configuration for the given host name, if such a configuration exists.
    `void` | `resume()` | Resume the endpoint, which will make it start accepting new connections again.
    `protected abstract U` | `serverSocketAccept()` |
    `void` | `setAcceptCount​(int acceptCount)` |
    `void` | `setAcceptorThreadPriority​(int acceptorThreadPriority)` |
    `void` | `setAddress​(java.net.InetAddress address)` |
    `void` | `setAttribute​(java.lang.String name, java.lang.Object value)` | Generic property setter called when a property for which a specific setter already exists within the `ProtocolHandler` needs to be made available to sub-components.
    `void` | `setBindOnInit​(boolean b)` |
    `void` | `setConnectionLinger​(int connectionLinger)` |
    `void` | `setConnectionTimeout​(int soTimeout)` |
    `void` | `setDaemon​(boolean b)` |
    `void` | `setDefaultSSLHostConfigName​(java.lang.String defaultSSLHostConfigName)` |
    `void` | `setDomain​(java.lang.String domain)` |
    `void` | `setExecutor​(java.util.concurrent.Executor executor)` |
    `void` | `setExecutorTerminationTimeoutMillis​(long executorTerminationTimeoutMillis)` |
    `void` | `setHandler​(AbstractEndpoint.Handler<S> handler)` |
    `void` | `setKeepAliveTimeout​(int keepAliveTimeout)` |
    `void` | `setMaxConnections​(int maxCon)` |
    `void` | `setMaxKeepAliveRequests​(int maxKeepAliveRequests)` |
    `void` | `setMaxThreads​(int maxThreads)` |
    `void` | `setMinSpareThreads​(int minSpareThreads)` |
    `void` | `setName​(java.lang.String name)` |
    `void` | `setPort​(int port)` |
    `void` | `setPortOffset​(int portOffset)` |
    `boolean` | `setProperty​(java.lang.String name, java.lang.String value)` |
    `protected abstract boolean` | `setSocketOptions​(U socket)` |
    `void` | `setSSLEnabled​(boolean SSLEnabled)` |
    `void` | `setTcpNoDelay​(boolean tcpNoDelay)` |
    `void` | `setThreadPriority​(int threadPriority)` |
    `void` | `setUseAsyncIO​(boolean useAsyncIO)` |
    `void` | `setUseSendfile​(boolean useSendfile)` |
    `void` | `setUtilityExecutor​(java.util.concurrent.ScheduledExecutorService utilityExecutor)` |
    `void` | `shutdownExecutor()` |
    `void` | `start()` |
    `protected void` | `startAcceptorThread()` |
    `abstract void` | `startInternal()` |
    `void` | `stop()` |
    `abstract void` | `stopInternal()` |
    `static long` | `toTimeout​(long timeout)` |
    `abstract void` | `unbind()` |
    `protected void` | `unlockAccept()` | Unlock the server socket acceptor threads using bogus connections.

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### sm

          protected static final StringManager sm

    - #### running

          protected volatile boolean running

      Running state of the endpoint.

    - #### paused

          protected volatile boolean paused

      Will be set to true whenever the endpoint is paused.

    - #### internalExecutor

          protected volatile boolean internalExecutor

      Are we using an internal executor

    - #### socketProperties

          protected final SocketProperties socketProperties

      Socket properties

    - #### acceptor

          protected Acceptor<U> acceptor

      Thread used to accept new connections and pass them to worker threads.

    - #### processorCache

          protected SynchronizedStack<SocketProcessorBase<S>> processorCache

      Cache for SocketProcessor objects

    - #### connections

          protected java.util.Map<U,​SocketWrapperBase<S>> connections

      Map holding all current connections keyed with the sockets.

    - #### sslHostConfigs

          protected java.util.concurrent.ConcurrentMap<java.lang.String,​SSLHostConfig> sslHostConfigs

    - #### acceptorThreadCount

          @Deprecated
          protected int acceptorThreadCount

      Deprecated.
      This attribute is hard-coded to `1` and is no longer configurable. It will be removed in Tomcat 10.1.
      Unused.

    - #### acceptorThreadPriority

          protected int acceptorThreadPriority

      Priority of the acceptor threads.

    - #### threadPriority

          protected int threadPriority

      Priority of the worker threads.

    - #### negotiableProtocols

          protected final java.util.List<java.lang.String> negotiableProtocols

    - #### attributes

          protected java.util.HashMap<java.lang.String,​java.lang.Object> attributes

      Attributes provide a way for configuration to be passed to sub-components without the `ProtocolHandler` being aware of the properties available on those sub-components.

  - ### Constructor Detail

    - #### AbstractEndpoint

          public AbstractEndpoint()

  - ### Method Detail

    - #### toTimeout

          public static long toTimeout​(long timeout)

    - #### getSocketProperties

          public SocketProperties getSocketProperties()

    - #### getConnections

          public java.util.Set<SocketWrapperBase<S>> getConnections()

      Get a set with the current open connections.
      Returns:
        A set with the open socket wrappers

    - #### getDefaultSSLHostConfigName

          public java.lang.String getDefaultSSLHostConfigName()

      Returns:
        The host name for the default SSL configuration for this endpoint - always in lower case.

    - #### setDefaultSSLHostConfigName

          public void setDefaultSSLHostConfigName​(java.lang.String defaultSSLHostConfigName)

    - #### addSslHostConfig

          public void addSslHostConfig​(SSLHostConfig sslHostConfig)
                                throws java.lang.IllegalArgumentException

      Add the given SSL Host configuration.
      Parameters:
        `sslHostConfig` - The configuration to add
      Throws:
        `java.lang.IllegalArgumentException` - If the host name is not valid or if a configuration has already been provided for that host

    - #### addSslHostConfig

          public void addSslHostConfig​(SSLHostConfig sslHostConfig,
                                       boolean replace)
                                throws java.lang.IllegalArgumentException

      Add the given SSL Host configuration, optionally replacing the existing configuration for the given host.
      Parameters:
        `sslHostConfig` - The configuration to add
        `replace` - If `true` replacement of an existing configuration is permitted, otherwise any such attempted replacement will trigger an exception
      Throws:
        `java.lang.IllegalArgumentException` - If the host name is not valid or if a configuration has already been provided for that host and replacement is not allowed

    - #### removeSslHostConfig

          public SSLHostConfig removeSslHostConfig​(java.lang.String hostName)

      Removes the SSL host configuration for the given host name, if such a configuration exists.
      Parameters:
        `hostName` - The host name associated with the SSL host configuration to remove
      Returns:
        The SSL host configuration that was removed, if any

    - #### reloadSslHostConfig

          public void reloadSslHostConfig​(java.lang.String hostName)

      Re-read the configuration files for the SSL host and replace the existing SSL configuration with the updated settings. Note this replacement will happen even if the settings remain unchanged.
      Parameters:
        `hostName` - The SSL host for which the configuration should be reloaded. This must match a current SSL host

    - #### reloadSslHostConfigs

          public void reloadSslHostConfigs()

      Re-read the configuration files for all SSL hosts and replace the existing SSL configuration with the updated settings. Note this replacement will happen even if the settings remain unchanged.

    - #### findSslHostConfigs

          public SSLHostConfig[] findSslHostConfigs()

    - #### createSSLContext

          protected abstract void createSSLContext​(SSLHostConfig sslHostConfig)
                                            throws java.lang.Exception

      Create the SSLContext for the given SSLHostConfig.
      Parameters:
        `sslHostConfig` - The SSLHostConfig for which the SSLContext should be created
      Throws:
        `java.lang.Exception` - If the SSLContext cannot be created for the given SSLHostConfig

    - #### destroySsl

          protected void destroySsl()
                             throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### releaseSSLContext

          protected void releaseSSLContext​(SSLHostConfig sslHostConfig)

      Release the SSLContext, if any, associated with the SSLHostConfig.
      Parameters:
        `sslHostConfig` - The SSLHostConfig for which the SSLContext should be released

    - #### getSSLHostConfig

          protected SSLHostConfig getSSLHostConfig​(java.lang.String sniHostName)

      Look up the SSLHostConfig for the given host name. Lookup order is:
      1. exact match
      2. wild card match
      3. default SSLHostConfig
      Parameters:
        `sniHostName` - Host name - must be in lower case
      Returns:
        The SSLHostConfig for the given host name.

    - #### getUseSendfile

          public boolean getUseSendfile()

    - #### setUseSendfile

          public void setUseSendfile​(boolean useSendfile)

    - #### getExecutorTerminationTimeoutMillis

          public long getExecutorTerminationTimeoutMillis()

    - #### setExecutorTerminationTimeoutMillis

          public void setExecutorTerminationTimeoutMillis​(long executorTerminationTimeoutMillis)

    - #### setAcceptorThreadPriority

          public void setAcceptorThreadPriority​(int acceptorThreadPriority)

    - #### getAcceptorThreadPriority

          public int getAcceptorThreadPriority()

    - #### setMaxConnections

          public void setMaxConnections​(int maxCon)

    - #### getMaxConnections

          public int getMaxConnections()

    - #### getConnectionCount

          public long getConnectionCount()

      Return the current count of connections handled by this endpoint, if the connections are counted (which happens when the maximum count of connections is limited), or `-1` if they are not. This property is added here so that this value can be inspected through JMX. It is visible on "ThreadPool" MBean.

      The count is incremented by the Acceptor before it tries to accept a new connection. Until the limit is reached and thus the count cannot be incremented, this value is more by 1 (the count of acceptors) than the actual count of connections that are being served.

      Returns:
        The count

    - #### setExecutor

          public void setExecutor​(java.util.concurrent.Executor executor)

    - #### getExecutor

          public java.util.concurrent.Executor getExecutor()

    - #### setUtilityExecutor

          public void setUtilityExecutor​(java.util.concurrent.ScheduledExecutorService utilityExecutor)

    - #### getUtilityExecutor

          public java.util.concurrent.ScheduledExecutorService getUtilityExecutor()

    - #### 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 final int getLocalPort()

    - #### getAddress

          public java.net.InetAddress getAddress()

    - #### setAddress

          public void setAddress​(java.net.InetAddress address)

    - #### getLocalAddress

          protected abstract java.net.InetSocketAddress getLocalAddress()
                                                                 throws java.io.IOException

      Obtain the network address the server socket is bound to. This primarily exists to enable the correct address to be used when unlocking the server socket since it removes the guess-work involved if no address is specifically set.
      Returns:
        The network address that the server socket is listening on or null if the server socket is not currently bound.
      Throws:
        `java.io.IOException` - If there is a problem determining the currently bound socket

    - #### setAcceptCount

          public void setAcceptCount​(int acceptCount)

    - #### getAcceptCount

          public int getAcceptCount()

    - #### getBindOnInit

          public boolean getBindOnInit()

    - #### setBindOnInit

          public void setBindOnInit​(boolean b)

    - #### getBindState

          protected AbstractEndpoint.BindState getBindState()

    - #### getKeepAliveTimeout

          public int getKeepAliveTimeout()

    - #### setKeepAliveTimeout

          public void setKeepAliveTimeout​(int keepAliveTimeout)

    - #### getTcpNoDelay

          public boolean getTcpNoDelay()

      Socket TCP no delay.
      Returns:
        The current TCP no delay setting for sockets created by this endpoint

    - #### setTcpNoDelay

          public void setTcpNoDelay​(boolean tcpNoDelay)

    - #### getConnectionLinger

          public int getConnectionLinger()

      Socket linger.
      Returns:
        The current socket linger time for sockets created by this endpoint

    - #### setConnectionLinger

          public void setConnectionLinger​(int connectionLinger)

    - #### getConnectionTimeout

          public int getConnectionTimeout()

      Socket timeout.
      Returns:
        The current socket timeout for sockets created by this endpoint

    - #### setConnectionTimeout

          public void setConnectionTimeout​(int soTimeout)

    - #### isSSLEnabled

          public boolean isSSLEnabled()

    - #### setSSLEnabled

          public void setSSLEnabled​(boolean SSLEnabled)

    - #### isAlpnSupported

          public abstract boolean isAlpnSupported()

      Identifies if the endpoint supports ALPN. Note that a return value of `true` implies that `isSSLEnabled()` will also return `true`.
      Returns:
        `true` if the endpoint supports ALPN in its current configuration, otherwise `false`.

    - #### setMinSpareThreads

          public void setMinSpareThreads​(int minSpareThreads)

    - #### getMinSpareThreads

          public int getMinSpareThreads()

    - #### setMaxThreads

          public void setMaxThreads​(int maxThreads)

    - #### getMaxThreads

          public int getMaxThreads()

    - #### setThreadPriority

          public void setThreadPriority​(int threadPriority)

    - #### getThreadPriority

          public int getThreadPriority()

    - #### getMaxKeepAliveRequests

          public int getMaxKeepAliveRequests()

    - #### setMaxKeepAliveRequests

          public void setMaxKeepAliveRequests​(int maxKeepAliveRequests)

    - #### setName

          public void setName​(java.lang.String name)

    - #### getName

          public java.lang.String getName()

    - #### setDomain

          public void setDomain​(java.lang.String domain)

    - #### getDomain

          public java.lang.String getDomain()

    - #### setDaemon

          public void setDaemon​(boolean b)

    - #### getDaemon

          public boolean getDaemon()

    - #### setUseAsyncIO

          public void setUseAsyncIO​(boolean useAsyncIO)

    - #### getUseAsyncIO

          public boolean getUseAsyncIO()

    - #### getDeferAccept

          protected boolean getDeferAccept()

    - #### getId

          public java.lang.String getId()

      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.
      Returns:
        the id

    - #### addNegotiatedProtocol

          public void addNegotiatedProtocol​(java.lang.String negotiableProtocol)

    - #### hasNegotiableProtocols

          public boolean hasNegotiableProtocols()

    - #### setHandler

          public void setHandler​(AbstractEndpoint.Handler<S> handler)

    - #### getHandler

          public AbstractEndpoint.Handler<S> getHandler()

    - #### setAttribute

          public void setAttribute​(java.lang.String name,
                                   java.lang.Object value)

      Generic property setter called when a property for which a specific setter already exists within the `ProtocolHandler` needs to be made available to sub-components. The specific setter will call this method to populate the attributes.
      Parameters:
        `name` - Name of property to set
        `value` - The value to set the property to

    - #### getAttribute

          public java.lang.Object getAttribute​(java.lang.String key)

      Used by sub-components to retrieve configuration information.
      Parameters:
        `key` - The name of the property for which the value should be retrieved
      Returns:
        The value of the specified property

    - #### setProperty

          public boolean setProperty​(java.lang.String name,
                                     java.lang.String value)

    - #### getProperty

          public java.lang.String getProperty​(java.lang.String name)

    - #### getCurrentThreadCount

          public int getCurrentThreadCount()

      Return the amount of threads that are managed by the pool.
      Returns:
        the amount of threads that are managed by the pool

    - #### getCurrentThreadsBusy

          public int getCurrentThreadsBusy()

      Return the amount of threads that are in use
      Returns:
        the amount of threads that are in use

    - #### isRunning

          public boolean isRunning()

    - #### isPaused

          public boolean isPaused()

    - #### createExecutor

          public void createExecutor()

    - #### shutdownExecutor

          public void shutdownExecutor()

    - #### unlockAccept

          protected void unlockAccept()

      Unlock the server socket acceptor threads using bogus connections.

    - #### processSocket

          public boolean processSocket​(SocketWrapperBase<S> socketWrapper,
                                       SocketEvent event,
                                       boolean dispatch)

      Process the given SocketWrapper with the given status. Used to trigger processing as if the Poller (for those endpoints that have one) selected the socket.
      Parameters:
        `socketWrapper` - The socket wrapper to process
        `event` - The socket event to be processed
        `dispatch` - Should the processing be performed on a new container thread
      Returns:
        if processing was triggered successfully

    - #### createSocketProcessor

          protected abstract SocketProcessorBase<S> createSocketProcessor​(SocketWrapperBase<S> socketWrapper,
                                                                          SocketEvent event)

    - #### bind

          public abstract void bind()
                             throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### unbind

          public abstract void unbind()
                               throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### startInternal

          public abstract void startInternal()
                                      throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### stopInternal

          public abstract void stopInternal()
                                     throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### init

          public final void init()
                          throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### start

          public final void start()
                           throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### startAcceptorThread

          protected void startAcceptorThread()

    - #### pause

          public void pause()

      Pause the endpoint, which will stop it accepting new connections and unlock the acceptor.

    - #### resume

          public void resume()

      Resume the endpoint, which will make it start accepting new connections again.

    - #### stop

          public final void stop()
                          throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### destroy

          public final void destroy()
                             throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### getLog

          protected abstract Log getLog()

    - #### initializeConnectionLatch

          protected LimitLatch initializeConnectionLatch()

    - #### countUpOrAwaitConnection

          protected void countUpOrAwaitConnection()
                                           throws java.lang.InterruptedException

      Throws:
        `java.lang.InterruptedException`

    - #### countDownConnection

          protected long countDownConnection()

    - #### closeServerSocketGraceful

          public final void closeServerSocketGraceful()

      Close the server socket (to prevent further connections) if the server socket was originally bound on `start()` (rather than on `init()`).
      See Also:
        `getBindOnInit()`

    - #### awaitConnectionsClose

          public final long awaitConnectionsClose​(long waitMillis)

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

    - #### doCloseServerSocket

          protected abstract void doCloseServerSocket()
                                               throws java.io.IOException

      Actually close the server socket but don't perform any other clean-up.
      Throws:
        `java.io.IOException` - If an error occurs closing the socket

    - #### serverSocketAccept

          protected abstract U serverSocketAccept()
                                           throws java.lang.Exception

      Throws:
        `java.lang.Exception`

    - #### setSocketOptions

          protected abstract boolean setSocketOptions​(U socket)

    - #### closeSocket

          protected void closeSocket​(U socket)

      Close the socket when the connection has to be immediately closed when an error occurs while configuring the accepted socket or trying to dispatch it for processing. The wrapper associated with the socket will be used for the close.
      Parameters:
        `socket` - The newly accepted socket

    - #### destroySocket

          protected abstract void destroySocket​(U socket)

      Close the socket. This is used when the connector is not in a state which allows processing the socket, or if there was an error which prevented the allocation of the socket wrapper.
      Parameters:
        `socket` - The newly accepted socket