@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.
ConnectionFactory
s 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.
ConnectionFactory
s 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.
ConnectionFactory
s 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 ConnectionFactory
s 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.AbstractLifeCycleListener
LifeCycle.Listener
Container.InheritedListener, Container.Listener
Graceful.Shutdown
Modifier and Type | Field and Description |
---|---|
protected Logger |
LOG |
Constructor and Description |
---|
AbstractConnector(Server server,
java.util.concurrent.Executor executor,
Scheduler scheduler,
ByteBufferPool pool,
int acceptors,
ConnectionFactory... factories) |
Modifier and Type | Method and Description |
---|---|
protected abstract void |
accept(int acceptorID) |
void |
addConnectionFactory(ConnectionFactory factory) |
void |
addFirstConnectionFactory(ConnectionFactory factory) |
void |
addIfAbsentConnectionFactory(ConnectionFactory factory) |
void |
clearConnectionFactories() |
protected void |
doStart()
Starts the managed lifecycle beans in the order they were added.
|
protected void |
doStop()
Stops the managed lifecycle beans in the reverse order they were added.
|
int |
getAcceptorPriorityDelta() |
int |
getAcceptors() |
ByteBufferPool |
getByteBufferPool() |
java.util.Collection<EndPoint> |
getConnectedEndPoints() |
java.util.Collection<ConnectionFactory> |
getConnectionFactories() |
<T> T |
getConnectionFactory(java.lang.Class<T> factoryType) |
ConnectionFactory |
getConnectionFactory(java.lang.String protocol) |
ConnectionFactory |
getDefaultConnectionFactory() |
java.lang.String |
getDefaultProtocol() |
java.util.concurrent.Executor |
getExecutor() |
long |
getIdleTimeout() |
java.lang.String |
getName()
Get the connector name if set.
|
java.util.List<java.lang.String> |
getProtocols() |
Scheduler |
getScheduler() |
Server |
getServer() |
protected boolean |
handleAcceptFailure(java.lang.Throwable ex) |
protected void |
interruptAcceptors() |
boolean |
isAccepting() |
boolean |
isShutdown() |
void |
join() |
void |
join(long timeout) |
protected void |
onEndPointClosed(EndPoint endp) |
protected void |
onEndPointOpened(EndPoint endp) |
ConnectionFactory |
removeConnectionFactory(java.lang.String protocol) |
void |
setAccepting(boolean accepting) |
void |
setAcceptorPriorityDelta(int acceptorPriorityDelta)
Set the acceptor thread priority delta.
|
void |
setConnectionFactories(java.util.Collection<ConnectionFactory> factories) |
void |
setDefaultProtocol(java.lang.String defaultProtocol) |
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. |
void |
setName(java.lang.String name)
Set a connector name.
|
java.util.concurrent.Future<java.lang.Void> |
shutdown() |
java.lang.String |
toString() |
addBean, addBean, addBean, addEventListener, addManaged, contains, destroy, dump, dump, dump, dump, dump, dumpBeans, dumpObject, dumpObjects, dumpStdErr, dumpThis, getBean, getBeans, getBeans, getContainedBeans, getContainedBeans, isAuto, isManaged, isUnmanaged, manage, removeBean, removeBeans, removeEventListener, setBeans, setStopTimeout, start, stop, unmanage, updateBean, updateBean, updateBeans
addLifeCycleListener, getState, getState, getStopTimeout, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stop
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
getTransport
addLifeCycleListener, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, start, stop, stop
addBean, addBean, addEventListener, getBean, getBeans, getBeans, getContainedBeans, isManaged, manage, removeBean, removeEventListener, unmanage
dump, dump, dump, dumpObject, dumpObjects, dumpSelf
protected final Logger LOG
public AbstractConnector(Server server, java.util.concurrent.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 java.util.concurrent.Executor getExecutor()
getExecutor
in interface Connector
Executor
used to submit taskspublic ByteBufferPool getByteBufferPool()
getByteBufferPool
in interface Connector
ByteBufferPool
to acquire buffers from and release buffers to@ManagedAttribute(value="The connection idle timeout in milliseconds") public long getIdleTimeout()
getIdleTimeout
in interface Connector
public 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 java.lang.Exception
ContainerLifeCycle
doStart
in class ContainerLifeCycle
java.lang.Exception
protected void interruptAcceptors()
public java.util.concurrent.Future<java.lang.Void> shutdown()
public boolean isShutdown()
isShutdown
in interface Graceful
protected void doStop() throws java.lang.Exception
ContainerLifeCycle
doStop
in class ContainerLifeCycle
java.lang.Exception
public void join() throws java.lang.InterruptedException
java.lang.InterruptedException
public void join(long timeout) throws java.lang.InterruptedException
java.lang.InterruptedException
protected abstract void accept(int acceptorID) throws java.io.IOException, java.lang.InterruptedException
java.io.IOException
java.lang.InterruptedException
public boolean isAccepting()
public void setAccepting(boolean accepting)
public ConnectionFactory getConnectionFactory(java.lang.String protocol)
getConnectionFactory
in interface Connector
protocol
- the next protocolConnectionFactory
associated with the protocol namepublic <T> T getConnectionFactory(java.lang.Class<T> factoryType)
getConnectionFactory
in interface Connector
public void addConnectionFactory(ConnectionFactory factory)
public void addFirstConnectionFactory(ConnectionFactory factory)
public void addIfAbsentConnectionFactory(ConnectionFactory factory)
public ConnectionFactory removeConnectionFactory(java.lang.String protocol)
public java.util.Collection<ConnectionFactory> getConnectionFactories()
getConnectionFactories
in interface Connector
public void setConnectionFactories(java.util.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 java.util.List<java.lang.String> getProtocols()
getProtocols
in interface Connector
public void clearConnectionFactories()
@ManagedAttribute(value="This connector\'s default protocol") public java.lang.String getDefaultProtocol()
public void setDefaultProtocol(java.lang.String defaultProtocol)
public ConnectionFactory getDefaultConnectionFactory()
getDefaultConnectionFactory
in interface Connector
ConnectionFactory
associated with the default protocol nameprotected boolean handleAcceptFailure(java.lang.Throwable ex)
public java.util.Collection<EndPoint> getConnectedEndPoints()
getConnectedEndPoints
in interface Connector
protected void onEndPointOpened(EndPoint endp)
protected void onEndPointClosed(EndPoint endp)
public Scheduler getScheduler()
getScheduler
in interface Connector
Scheduler
used to schedule taskspublic java.lang.String getName()
Connector
A ContextHandler
may be configured with
virtual hosts in the form "@connectorName" and will only serve
requests from the named connector.
public void setName(java.lang.String name)
name
- A connector name.public java.lang.String toString()
toString
in class AbstractLifeCycle
Copyright © 1995–2023 Webtide. All rights reserved.