ch.qos.logback.core.net.server

## Class ConcurrentServerRunner<T extends Client>

- java.lang.Object
- - ch.qos.logback.core.spi.ContextAwareBase
  - - ch.qos.logback.core.net.server.ConcurrentServerRunner<T>

All Implemented Interfaces:
  ServerRunner<T>, ContextAware, Runnable

    public abstract class ConcurrentServerRunner<T extends Client>
    extends ContextAwareBase
    implements Runnable, ServerRunner<T>

A concurrent `ServerRunner`.

An instance of this object is created with a `ServerListener` and an `Executor`. On invocation of the `#start()` method, it passes itself to the given `Executor` and returns immediately. On invocation of its `run()` method by the `Executor` it begins accepting client connections via its `ServerListener`. As each new `Client` is accepted, the client is configured with the runner's `LoggingContext` and is then passed to the `Executor` for concurrent execution of the client's service loop.

On invocation of the `stop()` method, the runner closes the listener and each of the connected clients (by invoking `Client.close()` effectively interrupting any blocked I/O calls and causing these concurrent subtasks to exit gracefully). This ensures that before the `stop()` method returns (1) all I/O resources have been released and (2) all of the threads of the `Executor` are idle.

Author:
  Carl Harris

### Field Summary

### Fields inherited from class ch.qos.logback.core.spi.ContextAwareBase

`context`

### Constructor Summary

Constructors
Constructor and Description
`ConcurrentServerRunner(ServerListener<T> listener, Executor executor)` Constructs a new server runner.

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`void` `accept(ClientVisitor<T> visitor)` Presents each connected client to the given visitor.
`protected abstract boolean` `configureClient(T client)` Configures a connected client.
`boolean` `isRunning()` Gets a flag indicating whether the server is currently running.
`void` `run()`
`protected void` `setRunning(boolean running)`
`void` `stop()` Stops execution of the runner.

### Methods inherited from class ch.qos.logback.core.spi.ContextAwareBase

`addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, getDeclaredOrigin, getStatusManager, setContext`

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

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

### Methods inherited from interface ch.qos.logback.core.spi.ContextAware

`addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, setContext`

### Constructor Detail

#### ConcurrentServerRunner

    public ConcurrentServerRunner(ServerListener<T> listener,
                                  Executor executor)

Constructs a new server runner.

Parameters:
  `listener` - the listener from which the server will accept new clients
  `executor` - a executor that will facilitate execution of the listening and client-handling tasks; while any `Executor` is allowed here, outside of unit testing the only reasonable choice is a bounded thread pool of some kind.

### Method Detail

#### isRunning

    public boolean isRunning()

Gets a flag indicating whether the server is currently running.

Specified by:
  `isRunning` in interface `ServerRunner<T extends Client>`
Returns:
  flag state

#### setRunning

    protected void setRunning(boolean running)

#### stop

    public void stop()
              throws IOException

Stops execution of the runner.

This method must cause all I/O and thread resources associated with the runner to be released. If the receiver has not been started, this method must have no effect.

Specified by:
  `stop` in interface `ServerRunner<T extends Client>`
Throws:
  `IOException`

#### accept

    public void accept(ClientVisitor<T> visitor)

Presents each connected client to the given visitor.

Specified by:
  `accept` in interface `ServerRunner<T extends Client>`
Parameters:
  `visitor` - the subject visitor

#### run

    public void run()

Specified by:
  `run` in interface `Runnable`

#### configureClient

    protected abstract boolean configureClient(T client)

Configures a connected client.

A subclass implements this method to perform any necessary configuration of the client object before its `Runnable.run()` method is invoked.

Parameters:
  `client` - the subject client
Returns:
  `true` if configuration was successful; if the return value is `false` the client connection will be dropped