// ========================================================================
// $Id: ThreadedServer.java,v 1.41 2005/12/10 00:38:20 gregwilkins Exp $
// Copyright 199-2004 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
package net.lightbody.bmp.proxy.jetty.util;
import net.lightbody.bmp.proxy.jetty.log.LogFactory;
import org.apache.commons.logging.Log;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/* ======================================================================= */
/**
* Threaded socket server. This class listens at a socket and gives the connections received to a
* pool of Threads
* <P>
* The class is abstract and derived classes must provide the handling for the connections.
* <P>
* The properties THREADED_SERVER_MIN_THREADS and THREADED_SERVER_MAX_THREADS can be set to control
* the number of threads created.
* <P>
*
* @version $Id: ThreadedServer.java,v 1.41 2005/12/10 00:38:20 gregwilkins Exp $
* @author Greg Wilkins
*/
abstract public class ThreadedServer extends ThreadPool
{
private static Log log = LogFactory.getLog(ThreadedServer.class);
/* ------------------------------------------------------------------- */
private InetAddrPort _address = null;
private int _soTimeOut = -1;
private int _lingerTimeSecs = 30;
private boolean _tcpNoDelay = true;
private int _acceptQueueSize = 0;
private int _acceptors = 1;
private transient Acceptor[] _acceptor;
private transient ServerSocket _listen = null;
private transient boolean _running = false;
/* ------------------------------------------------------------------- */
/*
* Construct
*/
public ThreadedServer()
{
}
/* ------------------------------------------------------------ */
/**
* @return The ServerSocket
*/
public ServerSocket getServerSocket()
{
return _listen;
}
/* ------------------------------------------------------------------- */
/**
* Construct for specific port.
*/
public ThreadedServer(int port)
{
setInetAddrPort(new InetAddrPort(port));
}
/* ------------------------------------------------------------------- */
/**
* Construct for specific address and port.
*/
public ThreadedServer(InetAddress address, int port)
{
setInetAddrPort(new InetAddrPort(address, port));
}
/* ------------------------------------------------------------------- */
/**
* Construct for specific address and port.
*/
public ThreadedServer(String host, int port) throws UnknownHostException
{
setInetAddrPort(new InetAddrPort(host, port));
}
/* ------------------------------------------------------------------- */
/**
* Construct for specific address and port.
*/
public ThreadedServer(InetAddrPort address)
{
setInetAddrPort(address);
}
/* ------------------------------------------------------------ */
/**
* Set the server InetAddress and port.
*
* @param address The Address to listen on, or 0.0.0.0:port for all interfaces.
*/
public synchronized void setInetAddrPort(InetAddrPort address)
{
if (_address != null && _address.equals(address)) return;
if (isStarted()) log.warn(this + " is started");
_address = address;
}
/* ------------------------------------------------------------ */
/**
* @return IP Address and port in a new Instance of InetAddrPort.
*/
public InetAddrPort getInetAddrPort()
{
if (_address == null) return null;
return new InetAddrPort(_address);
}
/* ------------------------------------------------------------ */
/**
* @param host
*/
public synchronized void setHost(String host) throws UnknownHostException
{
if (_address != null && _address.getHost() != null && _address.getHost().equals(host))
return;
if (isStarted()) log.warn(this + " is started");
if (_address == null)
_address = new InetAddrPort(host, 0);
else
_address.setHost(host);
}
/* ------------------------------------------------------------ */
/**
* @return Host name
*/
public String getHost()
{
if (_address == null || _address.getInetAddress() == null) return null;
return _address.getHost();
}
/* ------------------------------------------------------------ */
/**
* @param addr
*/
public synchronized void setInetAddress(InetAddress addr)
{
if (_address != null && _address.getInetAddress() != null
&& _address.getInetAddress().equals(addr)) return;
if (isStarted()) log.warn(this + " is started");
if (_address == null)
_address = new InetAddrPort(addr, 0);
else
_address.setInetAddress(addr);
}
/* ------------------------------------------------------------ */
/**
* @return IP Address
*/
public InetAddress getInetAddress()
{
if (_address == null) return null;
return _address.getInetAddress();
}
/* ------------------------------------------------------------ */
/**
* @param port
*/
public synchronized void setPort(int port)
{
if (_address != null && _address.getPort() == port) return;
if (isStarted()) log.warn(this + " is started");
if (_address == null)
_address = new InetAddrPort(port);
else
_address.setPort(port);
}
/* ------------------------------------------------------------ */
/**
* @return port number
*/
public int getPort()
{
if (_address == null) return 0;
return _address.getPort();
}
/* ------------------------------------------------------------ */
/**
* Set Max Read Time.
*
* @deprecated maxIdleTime is used instead.
*/
public void setMaxReadTimeMs(int ms)
{
log.warn("setMaxReadTimeMs is deprecated. Use setMaxIdleTimeMs()");
}
/* ------------------------------------------------------------ */
/**
* @return milliseconds
*/
public int getMaxReadTimeMs()
{
return getMaxIdleTimeMs();
}
/* ------------------------------------------------------------ */
/**
* @param ls seconds to linger or -1 to disable linger.
*/
public void setLingerTimeSecs(int ls)
{
_lingerTimeSecs = ls;
}
/* ------------------------------------------------------------ */
/**
* @return seconds.
*/
public int getLingerTimeSecs()
{
return _lingerTimeSecs;
}
/* ------------------------------------------------------------ */
/**
* @param tcpNoDelay if true then setTcpNoDelay(true) is called on accepted sockets.
*/
public void setTcpNoDelay(boolean tcpNoDelay)
{
_tcpNoDelay = tcpNoDelay;
}
/* ------------------------------------------------------------ */
/**
* @return true if setTcpNoDelay(true) is called on accepted sockets.
*/
public boolean getTcpNoDelay()
{
return _tcpNoDelay;
}
/* ------------------------------------------------------------ */
/**
* @return Returns the acceptQueueSize or -1 if not set.
*/
public int getAcceptQueueSize()
{
return _acceptQueueSize;
}
/* ------------------------------------------------------------ */
/**
* The size of the queue for unaccepted connections. If not set, will default to greater of
* maxThreads or 50.
*
* @param acceptQueueSize The acceptQueueSize to set.
*/
public void setAcceptQueueSize(int acceptQueueSize)
{
_acceptQueueSize = acceptQueueSize;
}
/* ------------------------------------------------------------ */
/**
* Set the number of threads used to accept connections. This should normally be 1, except when
* multiple CPUs are available and low latency is a high priority.
*/
public void setAcceptorThreads(int n)
{
_acceptors = n;
}
/* ------------------------------------------------------------ */
/**
* Get the nmber of threads used to accept connections
*/
public int getAcceptorThreads()
{
return _acceptors;
}
/* ------------------------------------------------------------------- */
/**
* Handle new connection. This method should be overridden by the derived class to implement the
* required handling. It is called by a thread created for it and does not need to return until
* it has finished it's task
*/
protected void handleConnection(InputStream in, OutputStream out)
{
throw new Error("Either handlerConnection must be overridden");
}
/* ------------------------------------------------------------------- */
/**
* Handle new connection. If access is required to the actual socket, override this method
* instead of handleConnection(InputStream in,OutputStream out). The default implementation of
* this just calls handleConnection(InputStream in,OutputStream out).
*/
protected void handleConnection(Socket connection) throws IOException
{
if (log.isDebugEnabled()) log.debug("Handle " + connection);
InputStream in = connection.getInputStream();
OutputStream out = connection.getOutputStream();
handleConnection(in, out);
out.flush();
in = null;
out = null;
connection.close();
}
/* ------------------------------------------------------------ */
/**
* Handle Job. Implementation of ThreadPool.handle(), calls handleConnection.
*
* @param job A Connection.
*/
public void handle(Object job)
{
Socket socket = (Socket) job;
try
{
if (_tcpNoDelay) socket.setTcpNoDelay(true);
handleConnection(socket);
}
catch (Exception e)
{
log.debug("Connection problem", e);
}
finally
{
try
{
socket.close();
}
catch (Exception e)
{
log.debug("Connection problem", e);
}
}
}
/* ------------------------------------------------------------ */
/**
* New server socket. Creates a new servers socket. May be overriden by derived class to create
* specialist serversockets (eg SSL).
*
* @param address Address and port
* @param acceptQueueSize Accept queue size
* @return The new ServerSocket
* @exception java.io.IOException
*/
protected ServerSocket newServerSocket(InetAddrPort address, int acceptQueueSize)
throws java.io.IOException
{
if (address == null) return new ServerSocket(0, acceptQueueSize);
return new ServerSocket(address.getPort(), acceptQueueSize, address.getInetAddress());
}
/* ------------------------------------------------------------ */
/**
* Accept socket connection. May be overriden by derived class to create specialist
* serversockets (eg SSL).
*
* @deprecated use acceptSocket(int timeout)
* @param ignored
* @param timeout The time to wait for a connection. Normally passed the ThreadPool maxIdleTime.
* @return Accepted Socket
*/
protected Socket acceptSocket(ServerSocket ignored, int timeout)
{
return acceptSocket(timeout);
}
/* ------------------------------------------------------------ */
/**
* Accept socket connection. May be overriden by derived class to create specialist
* serversockets (eg SSL).
*
* @param serverSocket
* @param timeout The time to wait for a connection. Normally passed the ThreadPool maxIdleTime.
* @return Accepted Socket
*/
protected Socket acceptSocket(int timeout)
{
try
{
Socket s = null;
if (_listen != null)
{
if (_soTimeOut != timeout)
{
_soTimeOut = timeout;
_listen.setSoTimeout(_soTimeOut);
}
s = _listen.accept();
try
{
if (getMaxIdleTimeMs() >= 0) s.setSoTimeout(getMaxIdleTimeMs());
if (_lingerTimeSecs >= 0)
s.setSoLinger(true, _lingerTimeSecs);
else
s.setSoLinger(false, 0);
}
catch (Exception e)
{
LogSupport.ignore(log, e);
}
}
return s;
}
catch (java.net.SocketException e)
{
// TODO - this is caught and ignored due strange
// exception from linux java1.2.v1a
LogSupport.ignore(log, e);
}
catch (InterruptedIOException e)
{
LogSupport.ignore(log, e);
}
catch (IOException e)
{
log.warn(LogSupport.EXCEPTION, e);
}
return null;
}
/* ------------------------------------------------------------------- */
/**
* Open the server socket. This method can be called to open the server socket in advance of
* starting the listener. This can be used to test if the port is available.
*
* @exception IOException if an error occurs
*/
public void open() throws IOException
{
if (_listen == null)
{
_listen = newServerSocket(_address, _acceptQueueSize);
if (_address == null)
_address = new InetAddrPort(_listen.getInetAddress(), _listen.getLocalPort());
else
{
if (_address.getInetAddress() == null)
_address.setInetAddress(_listen.getInetAddress());
if (_address.getPort() == 0) _address.setPort(_listen.getLocalPort());
}
_soTimeOut = getMaxIdleTimeMs();
if (_soTimeOut >= 0) _listen.setSoTimeout(_soTimeOut);
}
}
/* ------------------------------------------------------------------- */
/*
* Start the ThreadedServer listening
*/
public synchronized void start() throws Exception
{
try
{
if (isStarted()) return;
open();
_running = true;
_acceptor = new Acceptor[_acceptors];
for (int a = 0; a < _acceptor.length; a++)
{
_acceptor[a] = new Acceptor();
_acceptor[a].setDaemon(isDaemon());
_acceptor[a].start();
}
super.start();
}
catch (Exception e)
{
log.warn("Failed to start: " + this);
throw e;
}
}
/* --------------------------------------------------------------- */
public void stop() throws InterruptedException
{
synchronized (this)
{
// Signal that we are stopping
_running = false;
// Close the listener socket.
if (log.isDebugEnabled()) log.debug("closing " + _listen);
try
{
if (_listen != null) _listen.close();
_listen=null;
}
catch (IOException e)
{
log.warn(LogSupport.EXCEPTION, e);
}
// Do we have an acceptor thread (running or not)
Thread.yield();
for (int a = 0; _acceptor!=null && a<_acceptor.length; a++)
{
Acceptor acc = _acceptor[a];
if (acc != null)
acc.interrupt();
}
Thread.sleep(100);
for (int a = 0; _acceptor!=null && a<_acceptor.length; a++)
{
Acceptor acc = _acceptor[a];
if (acc != null)
{
acc.forceStop();
_acceptor[a] = null;
}
}
}
// Stop the thread pool
try
{
super.stop();
}
catch (Exception e)
{
log.warn(LogSupport.EXCEPTION, e);
}
finally
{
synchronized (this)
{
_acceptor = null;
}
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/**
* Kill a job. This method closes IDLE and socket associated with a job
*
* @param thread
* @param job
*/
protected void stopJob(Thread thread, Object job)
{
if (job instanceof Socket)
{
try
{
((Socket) job).close();
}
catch (Exception e)
{
LogSupport.ignore(log, e);
}
}
super.stopJob(thread, job);
}
/* ------------------------------------------------------------ */
public String toString()
{
if (_address == null) return getName() + "@0.0.0.0:0";
if (_listen != null)
return getName() + "@" + _listen.getInetAddress().getHostAddress() + ":"
+ _listen.getLocalPort();
return getName() + "@" + getInetAddrPort();
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
private class Acceptor extends Thread
{
/* ------------------------------------------------------------ */
public void run()
{
ThreadedServer threadedServer = ThreadedServer.this;
try
{
this.setName("Acceptor " + _listen);
while (_running)
{
try
{
// Accept a socket
Socket socket = acceptSocket(_soTimeOut);
// Handle the socket
if (socket != null)
{
if (_running)
threadedServer.run(socket);
else
socket.close();
}
}
catch (Throwable e)
{
if (_running)
log.warn(LogSupport.EXCEPTION, e);
else
log.debug(LogSupport.EXCEPTION, e);
}
}
}
finally
{
if (_running)
log.warn("Stopping " + this.getName());
else
log.info("Stopping " + this.getName());
synchronized (threadedServer)
{
if (_acceptor != null)
{
for (int a = 0; a < _acceptor.length; a++)
if (_acceptor[a] == this)
_acceptor[a] = null;
}
threadedServer.notifyAll();
}
}
}
/* ------------------------------------------------------------ */
void forceStop()
{
if (_listen != null && _address != null)
{
InetAddress addr = _address.getInetAddress();
try
{
if (addr == null || addr.toString().startsWith("0.0.0.0"))
addr = InetAddress.getByName("127.0.0.1");
if (log.isDebugEnabled())
log.debug("Self connect to close listener " + addr + ":"
+ _address.getPort());
Socket socket = new Socket(addr, _address.getPort());
Thread.yield();
socket.close();
Thread.yield();
}
catch (IOException e)
{
if (log.isDebugEnabled())
log.debug("problem stopping acceptor " + addr + ": ", e);
}
}
}
}
}