@ManagedObject(value="Abstract implementation of the Connector Interface") public abstract class AbstractConnector extends ContainerLifeCycle implements Connector, Dumpable
An abstract implementation of Connector that provides a ConnectionFactory mechanism
for creating Connection instances for various protocols (HTTP, SSL, etc).
Executor service is used to run all active tasks needed by this connector such as accepting connections
or handle HTTP requests. The default is to use the Server.getThreadPool() as an executor.
Scheduler service is used to monitor the idle timeouts of all connections and is also made available
to the connections to time such things as asynchronous request timeouts. The default is to use a new
ScheduledExecutorScheduler instance.
ByteBufferPool service is made available to all connections to be used to acquire and release
ByteBuffer instances from a pool. The default is to use a new ArrayByteBufferPool instance.
ContainerLifeCycle super class and
may either be managed or unmanaged beans.
ConnectionFactory instances, each of which are known by their
protocol name. The protocol name may be a real protocol (e.g. "http/1.1" or "h2") or it may be a private name
that represents a special connection factory. For example, the name "SSL-http/1.1" is used for
an SslConnectionFactory that has been instantiated with the HttpConnectionFactory as it's
next protocol.
ConnectionFactory may be constructor injected or modified with the
methods addConnectionFactory(ConnectionFactory), removeConnectionFactory(String) and
setConnectionFactories(Collection). Only a single ConnectionFactory instance may be configured
per protocol name, so if two factories with the same ConnectionFactory.getProtocol() are set, then
the second will replace the first.
The protocol factory used for newly accepted connections is specified by
the method setDefaultProtocol(String) or defaults to the protocol of the first configured factory.
Each Connection factory type is responsible for the configuration of the protocols that it accepts. Thus to
configure the HTTP protocol, you pass a HttpConfiguration instance to the HttpConnectionFactory
(or other factories that can also provide HTTP Semantics). Similarly the SslConnectionFactory is
configured by passing it a SslContextFactory and a next protocol name.
ConnectionFactorys may simply create a Connection instance to support a specific
protocol. For example, the HttpConnectionFactory will create a HttpConnection instance
that can handle http/1.1, http/1.0 and http/0.9.
ConnectionFactorys may also create a chain of Connection instances, using other ConnectionFactory instances.
For example, the SslConnectionFactory is configured with a next protocol name, so that once it has accepted
a connection and created an SslConnection, it then used the next ConnectionFactory from the
connector using the getConnectionFactory(String) method, to create a Connection instance that
will handle the unencrypted bytes from the SslConnection. If the next protocol is "http/1.1", then the
SslConnectionFactory will have a protocol name of "SSL-http/1.1" and lookup "http/1.1" for the protocol
to run over the SSL connection.
ConnectionFactorys may also create temporary Connection instances that will exchange bytes
over the connection to determine what is the next protocol to use. For example the ALPN protocol is an extension
of SSL to allow a protocol to be specified during the SSL handshake. ALPN is used by the HTTP/2 protocol to
negotiate the protocol that the client and server will speak. Thus to accept a HTTP/2 connection, the
connector will be configured with ConnectionFactorys for "SSL-ALPN", "h2", "http/1.1"
with the default protocol being "SSL-ALPN". Thus a newly accepted connection uses "SSL-ALPN", which specifies a
SSLConnectionFactory with "ALPN" as the next protocol. Thus an SSL connection instance is created chained to an ALPN
connection instance. The ALPN connection then negotiates with the client to determined the next protocol, which
could be "h2" or the default of "http/1.1". Once the next protocol is determined, the ALPN connection
calls getConnectionFactory(String) to create a connection instance that will replace the ALPN connection as
the connection chained to the SSL connection.
Exception service passed to the constructor.
The acceptor tasks run in a loop while the connector is running and repeatedly call the abstract accept(int) method.
The implementation of the accept method must:
getDefaultConnectionFactory() ConnectionFactory.newConnection(Connector, org.eclipse.jetty.io.EndPoint)
method to create a new Connection instance.AbstractLifeCycle.AbstractLifeCycleListenerLifeCycle.ListenerContainer.InheritedListener, Container.Listener| Modifier and Type | Field and Description |
|---|---|
protected Logger |
LOG |
FAILED, RUNNING, STARTED, STARTING, STOP_ON_FAILURE, STOPPED, STOPPING| Constructor and Description |
|---|
AbstractConnector(Server server,
Executor executor,
Scheduler scheduler,
ByteBufferPool pool,
int acceptors,
ConnectionFactory... factories) |
addBean, addBean, addBean, addEventListener, addManaged, contains, destroy, dump, dump, dump, dump, dump, dumpBeans, dumpObject, dumpStdErr, dumpThis, getBean, getBeans, getBeans, isManaged, manage, removeBean, removeBeans, removeEventListener, setBeans, setStopTimeout, start, stop, unmanage, updateBean, updateBean, updateBeansaddLifeCycleListener, getState, getState, getStopTimeout, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stopclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitgetTransportaddLifeCycleListener, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stopprotected final Logger LOG
public AbstractConnector(Server server, Executor executor, Scheduler scheduler, ByteBufferPool pool, int acceptors, ConnectionFactory... factories)
server - The server this connector will be added to. Must not be null.executor - An executor for this connector or null to use the servers executorscheduler - A scheduler for this connector or null to either a Scheduler set as a server bean or if none set, then a new ScheduledExecutorScheduler instance.pool - A buffer pool for this connector or null to either a ByteBufferPool set as a server bean or none set, the new ArrayByteBufferPool instance.acceptors - the number of acceptor threads to use, or -1 for a default value. If 0, then no acceptor threads will be launched and some other mechanism will need to be used to accept new connections.factories - The Connection Factories to use.public Server getServer()
public Executor getExecutor()
getExecutor in interface ConnectorExecutor used to submit taskspublic ByteBufferPool getByteBufferPool()
getByteBufferPool in interface ConnectorByteBufferPool to acquire buffers from and release buffers to@ManagedAttribute(value="Idle timeout") public long getIdleTimeout()
getIdleTimeout in interface Connectorpublic void setIdleTimeout(long idleTimeout)
Sets the maximum Idle time for a connection, which roughly translates to the Socket.setSoTimeout(int)
call, although with NIO implementations other mechanisms may be used to implement the timeout.
The max idle time is applied:
This value is interpreted as the maximum time between some progress being made on the connection. So if a single byte is read or written, then the timeout is reset.
idleTimeout - the idle timeout@ManagedAttribute(value="number of acceptor threads") public int getAcceptors()
protected void doStart()
throws Exception
doStart in class ContainerLifeCycleExceptionprotected void interruptAcceptors()
protected void doStop()
throws Exception
doStop in class ContainerLifeCycleExceptionpublic void join()
throws InterruptedException
InterruptedExceptionpublic void join(long timeout)
throws InterruptedException
InterruptedExceptionprotected abstract void accept(int acceptorID)
throws IOException,
InterruptedException
IOExceptionInterruptedExceptionprotected boolean isAccepting()
public ConnectionFactory getConnectionFactory(String protocol)
getConnectionFactory in interface Connectorprotocol - the next protocolConnectionFactory associated with the protocol namepublic <T> T getConnectionFactory(Class<T> factoryType)
getConnectionFactory in interface Connectorpublic void addConnectionFactory(ConnectionFactory factory)
public void addFirstConnectionFactory(ConnectionFactory factory)
public void addIfAbsentConnectionFactory(ConnectionFactory factory)
public ConnectionFactory removeConnectionFactory(String protocol)
public Collection<ConnectionFactory> getConnectionFactories()
getConnectionFactories in interface Connectorpublic void setConnectionFactories(Collection<ConnectionFactory> factories)
@ManagedAttribute(value="The priority delta to apply to acceptor threads") public int getAcceptorPriorityDelta()
public void setAcceptorPriorityDelta(int acceptorPriorityDelta)
This allows the acceptor thread to run at a different priority. Typically this would be used to lower the priority to give preference to handling previously accepted connections rather than accepting new connections
acceptorPriorityDelta - the acceptor priority delta@ManagedAttribute(value="Protocols supported by this connector") public List<String> getProtocols()
getProtocols in interface Connectorpublic void clearConnectionFactories()
@ManagedAttribute(value="This connector\'s default protocol") public String getDefaultProtocol()
public void setDefaultProtocol(String defaultProtocol)
public ConnectionFactory getDefaultConnectionFactory()
getDefaultConnectionFactory in interface ConnectorConnectionFactory associated with the default protocol namepublic Collection<EndPoint> getConnectedEndPoints()
getConnectedEndPoints in interface Connectorprotected void onEndPointOpened(EndPoint endp)
protected void onEndPointClosed(EndPoint endp)
public Scheduler getScheduler()
getScheduler in interface ConnectorScheduler used to schedule taskspublic String getName()
ConnectorA ContextHandler may be configured with
virtual hosts in the form "@connectorName" and will only serve
requests from the named connector.
public void setName(String name)
name - A connector name.Copyright © 1995–2017 Webtide. All rights reserved.