HttpServerEndpoint instances contain a host name
* and a TCP port number, as well as an optional {@link
* ServerSocketFactory} for customizing the type of
* ServerSocket to use and an optional {@link
* SocketFactory} for customizing the type of {@link Socket} that
* client endpoints will use. The port number is the local TCP port
* to bind to when listening for incoming socket connections. If the
* port number is zero, then each listen operation will bind to a free
* (non-zero) port, which will be the port number contained in the
* resulting {@link HttpEndpoint}. The host name contained in an
* HttpServerEndpoint controls the host name that will be
* contained in the HttpEndpoint instances produced when
* {@link #enumerateListenEndpoints enumerateListenEndpoints} is
* invoked to listen on the HttpServerEndpoint (this host
* name does not affect the behavior of listen operations themselves).
* If the host name in an HttpServerEndpoint is
* null, then the host name in the
* HttpEndpoint instances that it produces will be the IP
* address string obtained from {@link InetAddress#getLocalHost
* InetAddress.getLocalHost} when {@link #enumerateListenEndpoints
* enumerateListenEndpoints} is invoked.
*
*
HttpServerEndpoint instances map incoming HTTP
* messages to requests; when possible, underlying TCP connections are
* persisted to accommodate multiple non-overlapping incoming
* requests. Inbound request data is received as the
* entity-body of an HTTP POST request; outbound response
* data is sent as the entity-body of the corresponding
* HTTP return message. For information on HTTP, refer to RFC 2616. Note that
* providing socket factories that produce SSL sockets does not result
* in endpoints that are fully HTTPS capable.
*
*
A ServerSocketFactory used with an
* HttpServerEndpoint must implement {@link Object#equals
* Object.equals} to obey the guidelines that are specified for
* equals methods of {@link
* net.jini.jeri.ServerEndpoint.ListenEndpoint ListenEndpoint}
* instances. A SocketFactory used with a
* HttpServerEndpoint should be serializable and must
* implement Object.equals to obey the guidelines that
* are specified for equals methods of {@link Endpoint}
* instances.
*
*
* @see HttpEndpoint
* @since 2.0
**/
public final class HttpServerEndpoint implements ServerEndpoint {
/**
* pool of threads for executing tasks in system thread group:
* used for socket accept threads
**/
private static final Executor systemThreadPool =
(Executor) Security.doPrivileged(new GetThreadPoolAction(false));
/** HTTP server manager */
private static final HttpServerManager serverManager;
/** idle connection timer */
private static final ConnectionTimer connTimer;
static {
HttpSettings hs = HttpEndpoint.getHttpSettings();
serverManager = new HttpServerManager(hs.getResponseAckTimeout());
connTimer = new ConnectionTimer(hs.getServerConnectionTimeout());
}
/** server transport logger */
private static final Logger logger =
Logger.getLogger("net.jini.jeri.http.server");
/** local host name to fill in to corresponding HttpEndpoints */
private final String host;
/** port to listen on */
private final int port;
/** client socket factory used by corresponding HttpEndpoints */
private final SocketFactory sf;
/** socket factory used to create server sockets */
private final ServerSocketFactory ssf;
/**
* Returns an HttpServerEndpoint instance for the
* given TCP port number.
*
*
The host name contained in the returned
* HttpServerEndpoint will be null, so
* that when its {@link #enumerateListenEndpoints
* enumerateListenEndpoints} method produces an {@link
* HttpEndpoint}, the HttpEndpoint's host name will
* be the IP address string obtained from {@link
* InetAddress#getLocalHost InetAddress.getLocalHost}.
*
*
The ServerSocketFactory contained in the
* returned HttpServerEndpoint will be
* null, indicating that this endpoint will create
* ServerSocket objects directly. The
* SocketFactory contained in the returned
* HttpServerEndpoint will also be null.
*
* @param port the TCP port on the local host to listen on
*
* @return an HttpServerEndpoint instance
*
* @throws IllegalArgumentException if the port number is out of
* the range 0 to 65535 (inclusive)
**/
public static HttpServerEndpoint getInstance(int port) {
return getInstance(null, port, null, null);
}
/**
* Returns an HttpServerEndpoint instance for the given
* host name and TCP port number.
*
*
If host is null, then when the
* returned HttpServerEndpoint's {@link
* #enumerateListenEndpoints enumerateListenEndpoints} method
* produces an {@link HttpEndpoint}, the
* HttpEndpoint's host name will be the IP address
* string obtained from {@link InetAddress#getLocalHost
* InetAddress.getLocalHost}.
*
*
The ServerSocketFactory contained in the
* returned HttpServerEndpoint will be
* null, indicating that this endpoint will create
* ServerSocket objects directly. The
* SocketFactory contained in the returned
* HttpServerEndpoint will also be null.
*
* @param host the host name to be used in
* HttpEndpoint instances produced by listening on
* the returned HttpServerEndpoint, or
* null
*
* @param port the TCP port on the local host to listen on
*
* @return an HttpServerEndpoint instance
*
* @throws IllegalArgumentException if the port number is out of
* the range 0 to 65535 (inclusive)
**/
public static HttpServerEndpoint getInstance(String host, int port) {
return getInstance(host, port, null, null);
}
/**
* Returns an HttpServerEndpoint instance for the
* given host name and TCP port number that contains the given
* SocketFactory and
* ServerSocketFactory.
*
*
If host is null, then when the
* returned HttpServerEndpoint's {@link
* #enumerateListenEndpoints enumerateListenEndpoints} method
* produces an {@link HttpEndpoint}, the
* HttpEndpoint's host name will be the IP address
* string obtained from {@link InetAddress#getLocalHost
* InetAddress.getLocalHost}.
*
*
If the server socket factory argument is null,
* then this endpoint will create ServerSocket
* objects directly.
*
* @param host the host name to be used in
* HttpEndpoint instances produced by listening on
* the returned HttpServerEndpoint, or
* null
*
* @param port the TCP port on the local host to listen on
*
* @param sf the SocketFactory to use for this
* HttpServerEndpoint, or null
*
* @param ssf the ServerSocketFactory to use for this
* HttpServerEndpoint, or null
*
* @return an HttpServerEndpoint instance
*
* @throws IllegalArgumentException if the port number is out of
* the range 0 to 65535 (inclusive)
**/
public static HttpServerEndpoint getInstance(String host, int port,
SocketFactory sf,
ServerSocketFactory ssf)
{
return new HttpServerEndpoint(host, port, sf, ssf);
}
/**
* Constructs a new instance.
**/
private HttpServerEndpoint(String host, int port,
SocketFactory sf,
ServerSocketFactory ssf)
{
if (port < 0 || port > 0xFFFF) {
throw new IllegalArgumentException(
"port number out of range: " + port);
}
this.host = host;
this.port = port;
this.sf = sf;
this.ssf = ssf;
}
/**
* Returns the host name that will be used in
* HttpEndpoint instances produced by listening on
* this HttpServerEndpoint, or null if
* the IP address string obtained from {@link
* InetAddress#getLocalHost InetAddress.getLocalHost} will be
* used.
*
* @return the host name to use in HttpEndpoint
* instances produced from this object, or null
**/
public String getHost() {
return host;
}
/**
* Returns the TCP port that this HttpServerEndpoint
* listens on.
*
* @return the TCP port that this endpoint listens on
**/
public int getPort() {
return port;
}
/**
* Returns the SocketFactory that
* HttpEndpoint objects produced by listening on this
* HttpServerEndpoint will use to create
* Socket objects.
*
* @return the socket factory that client-side endpoints
* corresponding to this server endpoint will use to create
* sockets, or null if no factory will be used
**/
public SocketFactory getSocketFactory() {
return sf;
}
/**
* Returns the ServerSocketFactory that this endpoint
* uses to create ServerSocket objects.
*
* @return the socket factory that this endpoint uses to create
* sockets, or null if no factory is used
**/
public ServerSocketFactory getServerSocketFactory() {
return ssf;
}
/**
* {@inheritDoc}
*
* @throws NullPointerException {@inheritDoc}
**/
public InvocationConstraints checkConstraints(
InvocationConstraints constraints)
throws UnsupportedConstraintException
{
return Constraints.check(constraints, true);
}
/**
* Passes the {@link net.jini.jeri.ServerEndpoint.ListenEndpoint
* ListenEndpoint} for this HttpServerEndpoint to
* listenContext, which will ensure an active listen
* operation on the endpoint, and returns an
* HttpEndpoint instance corresponding to the listen
* operation chosen by listenContext.
*
*
If this HttpServerEndpoint's host name is not
* null, then the returned HttpEndpoint
* will contain that host name. If this
* HttpServerEndpoint's host name is
* null, then this method invokes {@link
* InetAddress#getLocalHost InetAddress.getLocalHost} to obtain an
* InetAddress for the local host. If
* InetAddress.getLocalHost throws an {@link
* UnknownHostException}, this method throws an
* UnknownHostException. The returned
* HttpEndpoint's host name will be the string
* returned by invoking {@link InetAddress#getHostAddress
* getHostAddress} on that InetAddress. If there is
* a security manager, its {@link
* SecurityManager#checkConnect(String,int) checkConnect} method
* will be invoked with the string returned by invoking {@link
* InetAddress#getHostName getHostName} on that same
* InetAddress as the host argument and
* -1 as the port argument; this could result in a
* SecurityException.
*
*
This method invokes addListenEndpoint on
* listenContext once, passing a
* ListenEndpoint as described below. If
* addListenEndpoint throws an exception, then this
* method throws that exception. Otherwise, this method returns
* an HttpEndpoint instance with the host name
* described above, the TCP port number bound by the listen
* operation represented by the {@link
* net.jini.jeri.ServerEndpoint.ListenHandle ListenHandle}
* returned by addListenEndpoint, and the same
* SocketFactory as this
* HttpServerEndpoint.
*
*
The ListenEndpoint passed to
* addListenEndpoint represents the TCP port number
* and ServerSocketFactory of this
* HttpServerEndpoint. Its methods behave as
* follows:
*
*
{@link net.jini.jeri.ServerEndpoint.ListenEndpoint#listen * ListenHandle listen(RequestDispatcher)}: * *
* * Listens for requests received on this endpoint's TCP port, * dispatching them to the supplied* *RequestDispatcher* in the form of {@link InboundRequest} instances. * *When the implementation of this method needs to create a new *
ServerSocket, it will do so by invoking one of the *createServerSocketmethods that returns a bound * server socket on the containedServerSocketFactory* if non-null, or it will create a *ServerSocketdirectly otherwise. * *If there is a security manager, its {@link * SecurityManager#checkListen checkListen} method will be invoked * with this endpoint's TCP port; this could result in a *
SecurityException. Furthermore, before a given *InboundRequestgets dispatched to the supplied * request dispatcher, the security manager's {@link * SecurityManager#checkAccept checkAccept} method must have been * successfully invoked in the security context of this *listeninvocation with the remote IP address and * port of theSocketused to receive the request. * ThecheckPermissionsmethod of the dispatched *InboundRequestalso performs this latter security * check. (Note that in some cases, the implementation may carry * out these security checks indirectly, such as through * invocations ofServerSocket's constructors or *acceptmethod.) * *Requests will be dispatched in a {@link PrivilegedAction} * wrapped by a {@link SecurityContext} obtained when this method * was invoked, with the {@link AccessControlContext} of that *
SecurityContextin effect. * *Dispatched requests will implement {@link * InboundRequest#populateContext populateContext} to populate the * supplied collection with context information representing the * request. * *
Throws {@link IOException} if an I/O exception occurs while * performing this operation, such as if the TCP port is already * in use. * *
Throws {@link SecurityException} if there is a security * manager and the invocation of its
checkListen* method fails. * *Throws {@link NullPointerException} if *
requestDispatcherisnull* *
{@link * net.jini.jeri.ServerEndpoint.ListenEndpoint#checkPermissions * void checkPermissions()}: * *
* * Verifies that the calling context has all of the security * permissions necessary to listen for requests on this endpoint. * ** *If there is a security manager, its
checkListen* method will be invoked with this endpoint's TCP port; this * could result in aSecurityException. * *Throws {@link SecurityException} if there is a security * manager and the invocation of its
checkListen* method fails. * *
{@link Object#equals boolean equals(Object)}: * *
* * Compares the specified object with this ** * @param listenContext theListenEndpointfor equality. * *This method returns
trueif and only if * ** *
* *- the specified object is also a
ListenEndpoint* produced by anHttpServerEndpoint, * *- the port in the specified object is equal to the port in * this object, and * *
- either this object and the specified object both have no *
ServerSocketFactoryor the *ServerSocketFactoryin the specified object has * the same class and is equal to the one in this object. * *
ListenContext to pass
* this HttpServerEndpoint's
* ListenEndpoint to
*
* @return the HttpEndpoint instance for sending
* requests to this HttpServerEndpoint's endpoint
* being listened on
*
* @throws UnknownHostException if this
* HttpServerEndpoint's host name is
* null and InetAddress.getLocalHost
* throws an UnknownHostException
*
* @throws IOException if an I/O exception occurs while performing
* this operation, such as if the TCP port is already in use
*
* @throws SecurityException if there is a security manager and
* either the invocation of its checkListen method
* fails or this HttpServerEndpoint's host name is
* null and the invocation of the security manager's
* checkConnect method fails
*
* @throws IllegalArgumentException {@inheritDoc}
*
* @throws NullPointerException {@inheritDoc}
**/
public Endpoint enumerateListenEndpoints(ListenContext listenContext)
throws IOException
{
if (listenContext == null) {
throw new NullPointerException();
}
String localHost = host;
if (localHost == null) {
InetAddress localAddr;
try {
localAddr = (InetAddress) Security.doPrivileged(
new PrivilegedExceptionAction() {
public Object run() throws UnknownHostException {
return LocalHostLookup.getLocalHost();
}
});
} catch (PrivilegedActionException e) {
/*
* Only expose UnknownHostException thrown directly by
* InetAddress.getLocalHost if it would also be thrown
* in the caller's security context; otherwise, throw
* a new UnknownHostException without the host name.
*/
LocalHostLookup.getLocalHost();
throw new UnknownHostException(
"access to resolve local host denied");
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
try {
sm.checkConnect(localAddr.getHostName(), -1);
} catch (SecurityException e) {
throw new SecurityException(
"access to resolve local host denied");
}
}
localHost = localAddr.getHostAddress();
}
LE listenEndpoint = new LE(); // REMIND: needn't be new?
ListenCookie listenCookie =
listenContext.addListenEndpoint(listenEndpoint);
if (!(listenCookie instanceof LE.Cookie)) {
throw new IllegalArgumentException();
}
LE.Cookie cookie = (LE.Cookie) listenCookie;
if (!listenEndpoint.equals(cookie.getLE())) {
throw new IllegalArgumentException();
}
return HttpEndpoint.getInstance(localHost, cookie.getPort(), sf);
}
/**
* Returns the hash code value for this
* HttpServerEndpoint.
*
* @return the hash code value for this
* HttpServerEndpoint
**/
public int hashCode() {
return port ^
(host != null ? host.hashCode() : 0) ^
(sf != null ? sf.hashCode() : 0) ^
(ssf != null ? ssf.hashCode() : 0);
}
/**
* Compares the specified object with this
* HttpServerEndpoint for equality.
*
* This method returns true if and only if
*
*
HttpServerEndpoint,
*
* SocketFactory or the ServerFactory in
* the specified object has the same class and is equal to the one
* in this object, and
*
* ServerSocketFactory or the
* ServerSocketFactory in the specified object has
* the same class and is equal to the one in this object.
*
* true if obj is equivalent to
* this object; false otherwise
**/
public boolean equals(Object obj) {
if (obj == this) {
return true;
} else if (!(obj instanceof HttpServerEndpoint)) {
return false;
}
HttpServerEndpoint other = (HttpServerEndpoint) obj;
return
Util.equals(host, other.host) &&
port == other.port &&
Util.sameClassAndEquals(sf, other.sf) &&
Util.sameClassAndEquals(ssf, other.ssf);
}
/**
* Returns a string representation of this
* HttpServerEndpoint.
*
* @return a string representation of this
* HttpServerEndpoint
**/
public String toString() {
return "HttpServerEndpoint[" +
(host != null ? host + ":" : "") + port +
(ssf != null ? "," + ssf : "") +
(sf != null ? "," + sf : "") + "]";
}
/**
* ListenEndpoint implementation.
**/
private class LE implements ListenEndpoint {
LE() { }
public void checkPermissions() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkListen(port);
}
}
public ListenHandle listen(RequestDispatcher requestDispatcher)
throws IOException
{
if (requestDispatcher == null) {
throw new NullPointerException();
}
ServerSocket serverSocket;
if (ssf != null) {
serverSocket = ssf.createServerSocket(port);
} else {
serverSocket = new ServerSocket(port);
}
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
(ssf == null ? "created server socket {0}" :
"created server socket {0} using factory {1}"),
new Object[] { serverSocket, ssf });
}
Cookie cookie = new Cookie(serverSocket.getLocalPort());
final LH listenHandle = new LH(requestDispatcher, serverSocket,
Security.getContext(), cookie);
listenHandle.startAccepting();
return listenHandle;
}
// following are required to implement equals:
private int getPort() { return port; }
private ServerSocketFactory getSSF() { return ssf; }
public int hashCode() {
return port ^ (ssf != null ? ssf.hashCode() : 0);
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
} else if (!(obj instanceof LE)) {
return false;
}
LE other = (LE) obj;
return port == other.getPort() &&
Util.sameClassAndEquals(ssf, other.getSSF());
}
public String toString() {
return "HttpServerEndpoint.LE[" + port +
(ssf != null ? "," + ssf : "") + "]";
}
/**
* ListenCookie implementation: identifies a listen operation
* by containing the local port that the server socket is
* bound to.
**/
private class Cookie implements ListenCookie {
private final int port;
Cookie(int port) { this.port = port; }
LE getLE() { return LE.this; }
int getPort() { return port; }
public String toString() {
return "HttpServerEndpoint.LE.Cookie[" + port + "]";
}
}
}
/**
* ListenHandle implementation: represents a listen operation.
**/
private static class LH implements ListenHandle {
private final RequestDispatcher requestDispatcher;
private final ServerSocket serverSocket;
private final SecurityContext context;
private final ListenCookie cookie;
private long acceptFailureTime = 0L; // local to accept thread
private int acceptFailureCount; // local to accept thread
private final Object lock = new Object();
private boolean closed = false;
private final Set conns = new HashSet();
LH(RequestDispatcher requestDispatcher,
ServerSocket serverSocket,
SecurityContext context,
ListenCookie cookie)
{
this.requestDispatcher = requestDispatcher;
this.serverSocket = serverSocket;
this.context = context;
this.cookie = cookie;
}
/**
* Starts the accept loop.
**/
void startAccepting() {
systemThreadPool.execute(new Runnable() {
public void run() {
try {
executeAcceptLoop();
} finally {
/*
* The accept loop is only started once, so
* after no more socket accepts will occur,
* ensure that the server socket is no longer
* listening.
*/
try {
serverSocket.close();
} catch (IOException e) {
}
}
}
}, toString() + " accept loop");
}
/**
* Runs the accept loop in the access control context
* preserved by LE.listen.
**/
private void executeAcceptLoop() {
AccessController.doPrivileged(context.wrap(new PrivilegedAction() {
public Object run() {
executeAcceptLoop0();
return null;
}
}), context.getAccessControlContext());
}
/**
* Executes the accept loop.
**/
private void executeAcceptLoop0() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
"accepted socket {0} from server socket {1}",
new Object[]{ socket, serverSocket });
}
setSocketOptions(socket);
new Connection(socket);
} catch (Throwable t) {
try {
/*
* If this listen operation has been stopped,
* then we expect the socket accept to throw
* an exception, so just terminate normally.
*/
synchronized (lock) {
if (closed) {
break;
}
}
try {
if (logger.isLoggable(Level.WARNING)) {
LogUtil.logThrow(logger, Level.WARNING,
HttpServerEndpoint.class,
"executeAcceptLoop",
"accept loop for {0} throws",
new Object[] { serverSocket }, t);
}
} catch (Throwable tt) {
}
} finally {
/*
* Always close the accepted socket (if any)
* if an exception occurs, but only after
* logging an unexpected exception.
*/
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
}
}
}
if (!(t instanceof SecurityException)) {
try {
Object[] snapshot;
synchronized (lock) {
snapshot = closed ? null : conns.toArray();
}
if (snapshot != null) {
for (int i = 0; i < snapshot.length; i++) {
((Connection) snapshot[i]).shutdown(false);
}
}
} catch (OutOfMemoryError e) {
} catch (Exception e) {
}
}
/*
* A NoClassDefFoundError can occur if no file
* descriptors are available, in which case this
* loop should not terminate.
*/
boolean knownFailure =
t instanceof Exception ||
t instanceof OutOfMemoryError ||
t instanceof NoClassDefFoundError;
if (knownFailure) {
if (continueAfterAcceptFailure(t)) {
continue;
} else {
return;
}
}
throw (Error) t;
}
}
}
/**
* Stops this listen operation.
**/
public void close() {
synchronized (lock) {
if (closed) {
return;
}
closed = true;
}
try {
serverSocket.close();
} catch (IOException e) {
}
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
"closed server socket {0}", serverSocket);
}
/*
* Iterating over conns without synchronization is safe
* at this point because no other thread will access it
* without verifying that closed is false in a
* synchronized block first.
*/
for (Iterator i = conns.iterator(); i.hasNext(); ) {
((Connection) i.next()).shutdown(true);
}
}
/**
* Returns a cookie to identify this listen operation.
**/
public ListenCookie getCookie() {
return cookie;
}
public String toString() {
return "HttpServerEndpoint.LH[" + serverSocket + "]";
}
/**
* Throttles the accept loop after ServerSocket.accept throws
* an exception, and decides whether to continue at all. The
* current code is borrowed from the JRMP implementation; it
* always continues, but it delays the loop after bursts of
* failed accepts.
**/
private boolean continueAfterAcceptFailure(Throwable t) {
/*
* If we get a burst of NFAIL failures in NMSEC milliseconds,
* then wait for ten seconds. This is to ensure that individual
* failures don't cause hiccups, but sustained failures don't
* hog the CPU in futile accept-fail-retry looping.
*/
final int NFAIL = 10;
final int NMSEC = 5000;
long now = System.currentTimeMillis();
if (acceptFailureTime == 0L ||
(now - acceptFailureTime) > NMSEC)
{
// failure time is very old, or this is first failure
acceptFailureTime = now;
acceptFailureCount = 0;
} else {
// failure window was started recently
acceptFailureCount++;
if (acceptFailureCount >= NFAIL) {
try {
Thread.sleep(10000);
} catch (InterruptedException ignore) {
}
// no need to reset counter/timer
}
}
return true;
}
/**
* HttpServerConnection subclass.
**/
private class Connection extends HttpServerConnection {
private final Socket socket;
private final Object connLock = new Object();
private boolean connClosed;
Connection(Socket socket) throws IOException {
super(socket, requestDispatcher, serverManager);
this.socket = socket;
boolean needShutdown = false;
synchronized (lock) {
if (closed) {
needShutdown = true; // shutdown after releasing lock
} else {
conns.add(this);
}
}
if (needShutdown) {
shutdown(true);
} else {
start();
}
}
public boolean shutdown(boolean force) {
synchronized (connLock) {
if (connClosed) {
return true;
}
connClosed = super.shutdown(force);
if (!connClosed) {
return false;
}
}
connTimer.cancelTimeout(this);
synchronized (lock) {
if (!closed) { // must not mutate set after closed
conns.remove(this);
}
}
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
"shut down connection on socket {0}", socket);
}
return true;
}
protected void checkPermissions() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkAccept(socket.getInetAddress().getHostAddress(),
socket.getPort());
}
}
protected InvocationConstraints checkConstraints(
InvocationConstraints constraints)
throws UnsupportedConstraintException
{
/*
* The transport layer aspects of all constraints
* supported by this transport provider are always
* satisfied by all requests on the server side, so
* this method can have the same static behavior as
* ServerCapabilities.checkConstraints does.
* (Otherwise, this operation would need to be
* parameterized by this connection or the request.)
*/
return Constraints.check(constraints, true);
}
/**
* Populates the context collection with information representing
* the connection.
**/
protected void populateContext(Collection context) {
Util.populateContext(context, socket.getInetAddress());
}
protected void idle() {
connTimer.scheduleTimeout(this, false);
}
protected void busy() {
connTimer.cancelTimeout(this);
}
}
}
/**
* Attempts to set desired socket options for a connected socket
* (TCP_NODELAY and SO_KEEPALIVE); ignores SocketException.
**/
private static void setSocketOptions(Socket socket) {
try {
socket.setTcpNoDelay(true);
} catch (SocketException e) {
if (logger.isLoggable(Levels.HANDLED)) {
LogUtil.logThrow(logger, Levels.HANDLED,
HttpServerEndpoint.class, "setSocketOptions",
"exception setting TCP_NODELAY on socket {0}",
new Object[] { socket }, e);
}
}
try {
socket.setKeepAlive(true);
} catch (SocketException e) {
if (logger.isLoggable(Levels.HANDLED)) {
LogUtil.logThrow(logger, Levels.HANDLED,
HttpServerEndpoint.class, "setSocketOptions",
"exception setting SO_KEEPALIVE on socket {0}",
new Object[] { socket }, e);
}
}
}
}