View Javadoc
   /************************************************************
   *                     Copyright                            *
   * Portions of this software are Copyright (c) 1993 - 2002, *
   * Chad Z. Hower (Kudzu) and the Indy Pit Crew              *
   *  - http://www.nevrona.com/Indy/                          *
   ************************************************************/
   package org.indy;
   
   import java.beans.Beans;
  
  import java.io.IOException;
  
  import java.net.InetAddress;
  import java.net.ServerSocket;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Vector;
  
  import org.indy.io.IndyIOException;
  import org.indy.io.ServerIOHandler;
  import org.indy.io.ServerIOHandlerSocket;
  
  import org.indy.util.IndyUtilities;
  
  
  /***
   *  Description of the Class
   *
   *@author     owen
   *@created    26 September 2002
   */
  public class TCPServer extends IndyComponent {
    private final List bindings = new ArrayList();
    private final CommandHandlers commandHandlers = new CommandHandlers(this);
    private final ServerListenerList listenerList = new ServerListenerList();
    private final List listenerThreadList = new ArrayList();
    private final List threadList = Collections.synchronizedList(new ArrayList());
    private volatile boolean commandHandlersEnabled;
    private boolean commandHandlersInitialized;
    private int defaultPort = 6666;
  
    //Execution listener is unicast
    private TCPServerExecuteListener executor;
    private RFCReply greeting;
    private boolean implicitIOHandler;
    private boolean implicitThreadManager;
    private ServerIOHandler ioHandler;
    private boolean active = false;
    private int listenQueue;
    private ListenerThread listenThread;
    private RFCReply maxConnectionReply;
    private int maxConnections;
    private RFCReplies relpyTexts = new RFCReplies();
    private RFCReply replyUnknownCommand;
    private int terminateWaitTime;
    private PeerThreadManager threadManager = new DefaultPeerThreadManager();
    transient private Vector TCPServerListeners;
  
    /***
   *   Constructor for the TCPServer object
   */
    public TCPServer() {
    }
  
    /***
   *  Description of the Method
   *
   *@param  thread  Description of the Parameter
   */
    protected void doAfterCommandHandler(PeerThread thread) {
      TCPServerListener[] l = listenerList.getArray();
  
      for (int i = 0; i < l.length; i++) {
        l[i].onAfterCommandHandler(this, thread);
      }
    }
  
    /***
   *  Description of the Method
   *
   *@param  thread  Description of the Parameter
   *@param  line    Description of the Parameter
   */
    protected void doBeforeCommandHandler(PeerThread thread, String line) {
      TCPServerListener[] l = listenerList.getArray();
  
      for (int i = 0; i < l.length; i++) {
        l[i].onBeforeCommandHandler(this, thread, line);
      }
    }
  
    /***
   *  Description of the Method
   *
   *@param  thread  Description of the Parameter
  */
   protected void doConnect(PeerThread thread) {
     TCPServerListener[] listeners = listenerList.getArray();
 
     for (int i = 0; i < listeners.length; i++) {
       listeners[i].onConnect(thread);
     }
   }
 
   /***
  *  Description of the Method
  *
  *@param  thread  Description of the Parameter
  */
   protected void doDisconnect(PeerThread thread) {
     TCPServerListener[] l = listenerList.getArray();
 
     for (int i = 0; i < l.length; i++) {
       l[i].onDisconnect(thread);
     }
   }
 
   /***
  *  Description of the Method
  *
  *@param  thread     Description of the Parameter
  *@param  exception  Description of the Parameter
  */
   protected void doException(PeerThread thread, IndyException exception) {
     if (listenerList.isEmpty()) {
       System.err.println("No Server Listener Available:");
       exception.printStackTrace();
 
       return;
     }
 
     TCPServerListener[] listeners = listenerList.getArray();
 
     for (int i = 0; i < listeners.length; i++) {
       listeners[i].onException(thread, exception);
     }
   }
 
   /***
  *  Description of the Method
  *
  *@param  thread             Description of the Parameter
  *@return                    Description of the Return Value
  *@throws  IndyException       Description of the Exception
  */
   protected boolean doExecute(PeerThread thread) throws IndyException {
     if (commandHandlersEnabled && (commandHandlers.size() > 0)) {
       String line = thread.getConnection().readLine();
 
       if (line.length() > 0) {
         doBeforeCommandHandler(thread, line);
 
         try {
           for (int i = 0, n = commandHandlers.size(); i < n; i++) {
             CommandHandler ch = commandHandlers.getCommandHandler(i);
 
             if (ch.isEnabled()) {
               if (ch.check(line, thread)) {
                 break;
               }
             }
 
             if (i == (n - 1)) {
               doNoCommandHandler(thread, line);
             }
           }
         }
          finally {
           doAfterCommandHandler(thread);
 
           return true;
         }
       }
     }
     else {
       if (executor != null) {
         executor.onExecute(this, thread.getConnection());
 
         return true;
       }
     }
 
     return false;
   }
 
   /***
  *  Description of the Method
  *
  *@param  thread     Description of the Parameter
  *@param  exception  Description of the Parameter
  */
   protected void doListenException(ListenerThread thread, 
                                    IndyException exception) {
     if (listenerList.isEmpty()) {
       //just do a stack trace and bail
       System.err.println("LISTEN EXCEPTION");
       exception.printStackTrace();
 
       return;
     }
 
     TCPServerListener[] listeners = listenerList.getArray();
 
     for (int i = 0; i < listeners.length; i++) {
       listeners[i].onListenException(thread, exception);
     }
   }
 
   /***
  *  Description of the Method
  *
  *@param  thread                  Description of the Parameter
  *@param  data                    Description of the Parameter
  *@exception  TCPServerException  Description of the Exception
  *@throws  IdTCPServerError       Description of the Exception
  */
   protected void doNoCommandHandler(PeerThread thread, String data)
                              throws TCPServerException {
     if (!commandHandlers.isEmpty()) {
       TCPServerListener[] listeners = listenerList.getArray();
 
       for (int i = 0; i < listeners.length; i++) {
         listeners[i].onNoCommandHandler(this, thread, data);
       }
     }
 
     else if (replyUnknownCommand.replyExists()) {
       try {
         thread.getConnection().writeRFCReply(replyUnknownCommand);
       }
        catch (IndyException ide) {
         throw new TCPServerException(ide.getMessage());
       }
     }
 
     else {
       throw new TCPServerException(IndyUtilities.getResourceString(
                                        "RSNoCommandHandlerFound"));
     }
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param b DOCUMENT ME!
    */
   public void addBinding(TCPServerBinding b) {
     bindings.add(b);
   }
 
   /***
  *  Adds a feature to the CommandHandlerListener attribute of the IdTCPServer
  *  object
  *
  *@param  l  The feature to be added to the CommandHandlerListener attribute
  */
   public void removeBinding(TCPServerBinding b) {
     bindings.remove(b);
   }
 
   /***
  *  Description of the Method
  *
  *@param  l  Description of the Parameter
  */
   /***
  *  Sets the active attribute of the IdTCPServer object
  *
  *@param  active               The new active value
  *@exception  IndyIOException  Description of the Exception
  */
   public void setActive(boolean makeActive) throws IndyIOException {
     if (!Beans.isDesignTime() && makeActive && (makeActive != active)) {
       try {
         ioHandler = new ServerIOHandlerSocket();
         ioHandler.init();
 
         if (bindings.isEmpty()) {
           bindings.add(new TCPServerBinding(null, defaultPort));
         }
 
         for (int i = 0, n = bindings.size(); i < n; i++) {
           TCPServerBinding binding = (TCPServerBinding) bindings.get(i);
           ServerSocket ss = null;
 
           int port = binding.getPort();
 
           if (binding.getHost() != null) {
             InetAddress addr = InetAddress.getByName(binding.getHost());
 
             ss = new ServerSocket(port, listenQueue, addr);
           }
           else {
             ss = new ServerSocket(port, listenQueue);
           }
 
           ListenerThread listener = new ListenerThread(this, ss);
 
           listenerThreadList.add(listener);
           listener.start();
         }
       }
        catch (IOException ioe) {
         throw new IndyIOException(ioe);
       }
     }
     else {
       try {
         System.err.println("Here");
 
         threadManager.terminateThreads();
         System.err.println("There");
 
         for (int i = 0, n = listenerThreadList.size(); i < n; i++) {
           ListenerThread listener = (ListenerThread) listenerThreadList.get(i);
 
           listener.terminateAndWait();
         }
 
         listenerThreadList.clear();
       }
        catch (InterruptedException ie) {
         ie.printStackTrace();
       }
     }
 
     active = makeActive;
   }
 
   /***
  *  Sets the port attribute of the IdTCPServer object
  *
  *@param  newPort  The new port value
  */
   public void setDefaultPort(int newPort) {
     this.defaultPort = newPort;
   }
 
   /***
  *  Sets the executionListener attribute of the IdTCPServer object
  *
  *@param  e  The new executionListener value
  */
   public void addServerExecuteListener(TCPServerExecuteListener e) { //throws TooManyListenersException{
 
     //    if(executor == null){
     executor = e;
 
     //    }
     //    else {
     //      throw new TooManyListenersException("Only one TCPServerExecuteListener is permitted at a time. Call removeServerExecuteListener() first");
     //    }
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param e DOCUMENT ME!
    */
   public void removeServerExecuteListener(TCPServerExecuteListener e) {
     executor = null;
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param listenQueue DOCUMENT ME!
    */
   public void setListenQueue(int listenQueue) {
     this.listenQueue = listenQueue;
   }
 
   /***
  *  Sets the threadMgr attribute of the IdTCPServer object
  *
  *@param  threadMgr  The new threadMgr value
  */
   public void setThreadManager(PeerThreadManager threadMgr) {
     threadManager = threadMgr;
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param index DOCUMENT ME!
    *
    * @return DOCUMENT ME!
    */
   public TCPServerBinding getBinding(int index) {
     return (TCPServerBinding) bindings.get(index);
   }
 
   /***
    * DOCUMENT ME!
    *
    * @return DOCUMENT ME!
    */
   public TCPServerBinding[] getBindings() {
     return (TCPServerBinding[]) bindings.toArray();
   }
 
   /***
  *  Gets the port attribute of the IdTCPServer object
  *
  *@return    The port value
  */
   public int getDefaultPort() {
     return defaultPort;
   }
 
   /***
  *  Gets the iOHandler attribute of the IdTCPServer object
  *
  *@return    The iOHandler value
  */
   public ServerIOHandler getIOHandler() {
     return ioHandler;
   }
 
   /***
    * DOCUMENT ME!
    *
    * @return DOCUMENT ME!
    */
   public int getListenQueue() {
     return listenQueue;
   }
 
   /***
  *  Gets the maxConnectionReply attribute of the IdTCPServer object
  *
  *@return    The maxConnectionReply value
  */
   public RFCReply getMaxConnectionReply() {
     return maxConnectionReply;
   }
 
   /***
  *  Gets the maxConnections attribute of the IdTCPServer object
  *
  *@return    The maxConnections value
  */
   public int getMaxConnections() {
     return maxConnections;
   }
 
   /***
  *  Gets the replyTexts attribute of the IdTCPServer object
  *
  *@return    The replyTexts value
  */
   public RFCReplies getReplyTexts() {
     return relpyTexts;
   }
 
   /***
  *  Gets the threadList attribute of the IdTCPServer object
  *
  *@return    The threadList value
  */
   public List getThreadList() {
     return threadList;
   }
 
   /***
  *  Gets the threadMgr attribute of the IdTCPServer object
  *
  *@return    The threadMgr value
  */
   public PeerThreadManager getThreadManager() {
     return threadManager;
   }
 
   /***
    * DOCUMENT ME!
    *
    * @return DOCUMENT ME!
    */
   public boolean isActive() {
     return active;
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param l DOCUMENT ME!
    */
   public synchronized void removeTCPServerListener(TCPServerListener l) {
     if ((TCPServerListeners != null) && TCPServerListeners.contains(l)) {
       Vector v = (Vector) TCPServerListeners.clone();
 
       v.removeElement(l);
       TCPServerListeners = v;
     }
   }
 
   /***
    * DOCUMENT ME!
    *
    * @param l DOCUMENT ME!
    */
   public synchronized void addTCPServerListener(TCPServerListener l) {
     Vector v = (TCPServerListeners == null)
                ? new Vector(2) : (Vector) TCPServerListeners.clone();
 
     if (!v.contains(l)) {
       v.addElement(l);
       TCPServerListeners = v;
     }
   }
 
   /***
  *  Collection for server listeners that handles syncing on the listener list
  *  on a request by request basis to reduce contention on the list at higher
  *  traffic volumes.
  *
  *@author     Owen Green
  *@created    26 September 2002
  */
   private class ServerListenerList {
     private final Collection listenerList = Collections.synchronizedCollection(
                                                 new HashSet());
 
     public void add(TCPServerListener l) {
       listenerList.add(l);
     }
 
     public void remove(TCPServerListener l) {
       listenerList.remove(l);
     }
 
     public TCPServerListener[] getArray() {
       return (TCPServerListener[]) listenerList.toArray(
                    new TCPServerListener[listenerList.size()]);
     }
 
     public boolean isEmpty() {
       return listenerList.isEmpty();
     }
   }
 }