public ServicePool(ServerService next,
    Executor executor) 
{
        this.next = next;
        this.executor = executor;
        this.threadPool = null;
}

 public ServicePool(ServerService next,
    String name,
    Properties properties) 
{
        this(next, name, new Options(properties).get("threads", 100));
}

 public ServicePool(ServerService next,
    String name,
    int threads) 
{
        this.next = next;
        final int keepAliveTime = (1000 * 60 * 5);
        threadPool = new ThreadPoolExecutor(threads, threads, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
        threadPool.setThreadFactory(new ThreadFactory() {
            private volatile int id = 0;
            public Thread newThread(Runnable arg0) {
                Thread thread = new Thread(arg0, name + " " + getNextID());
                return thread;
            }
            private int getNextID() {
                return id++;
            }
        });
        executor = threadPool;
        SystemInstance.get().setComponent(ServicePool.class, this);
}

 public String getIP() 
{
        return next.getIP();
}

Gets the ip number that the daemon is listening on.

 public String getName() 
{
        return next.getName();
}

Gets the name of the service. Used for display purposes only

 public int getPort() 
{
        return next.getPort();
}

Gets the port number that the daemon is listening on.

 public ThreadPoolExecutor getThreadPool() 
{
        return threadPool;
}

 public  void init(Properties props) throws Exception 
{
        // Do our stuff
        // Then call the next guy
        next.init(props);
}

Pulls out the access log information

 public  void service(Socket socket) throws ServiceException, IOException 
{
        final Runnable service = new Runnable() {
            public void run() {
                try {
                    if (stop.get()) return;
                    next.service(socket);
                } catch (SecurityException e) {
                    log.error("Security error: " + e.getMessage(), e);
                } catch (Throwable e) {
                    log.error("Unexpected error", e);
                } finally {
                    try {
                        // Once the thread is done with the socket, clean it up
                        // The ServiceDaemon does not close the sockets as it is
                        // single threaded and only accepts sockets and then
                        // hands them off to be proceeceed.  As the thread doing
                        // that processing it is our job to close the socket
                        // when we are finished with it.
                        if (socket != null) {
                            socket.close();
                        }
                    } catch (Throwable t) {
                        log.warning("Error while closing connection with client", t);
                    }
                }
            }
        };
        final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
        Runnable ctxCL = new Runnable() {
            public void run() {
                ClassLoader cl = Thread.currentThread().getContextClassLoader();
                Thread.currentThread().setContextClassLoader(tccl);
                try {
                    service.run();
                } finally {
                    Thread.currentThread().setContextClassLoader(cl);
                }
            }
        };
        executor.execute(ctxCL);
}

 public  void service(InputStream in,
    OutputStream out) throws ServiceException, IOException 
{

}

 public  void start() throws ServiceException 
{
        // Do our stuff
        // Then call the next guy
        next.start();
}

 public  void stop() throws ServiceException 
{
        // Do our stuff
        // Then call the next guy
        next.stop();
}