connectionlist.java

P2P协议GUNTELLA的java源代码

/*
 * Copyright (C) 2000-2001  Ken McCrary
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Email: [e-mail]
 */
package com.kenmccrary.jtella;

import java.util.List;
import java.util.LinkedList;
import java.util.Collections;
import java.util.Iterator;

import com.kenmccrary.jtella.util.Log;

/**
 *  Contains the set of current connections, the node connections
 *  can be in different states, not all may be active
 *
 */
public class ConnectionList
{
  private List currentConnectionList;
  
  ConnectionList()
  {
     currentConnectionList = Collections.synchronizedList(new LinkedList());
  }    
  
  /**
   *  Gets a list containing the connections
   *
   *  @return list of connections
   */
  public LinkedList getList()
  {
    return(new LinkedList(currentConnectionList));
  }    
  
  /**
   *  Adds a connection
   *
   *  @param connection new connection
   */
  void addConnection(NodeConnection connection)
  {
    synchronized(currentConnectionList)
    {
      currentConnectionList.add(connection);  
    }  
  }    
  
  /**
   *  Removes a connection
   *
   *  @param connection to remove
   */
  void removeConnection(NodeConnection connection)
  {
    synchronized(currentConnectionList)
    {
      currentConnectionList.remove(connection);
    }  
  }    
  
  /**
   *  Check if a connection exists to a host
   *
   *  @param ipAddress host address
   *  @return true if a connection exists to this IP address
   */
  boolean contains(String ipAddress)
  {
    boolean result = false;

    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while (i.hasNext() )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getConnectedServant().equals(ipAddress) )
          {    
            return true;  
          }    
        }    
     }    
     
    return result;
  }    

  /**
   *  Get active outgoing and incoming connections
   *
   *  @return active connections
   */
  List getActiveConnections()
  {
    List all = getActiveOutgoingConnections();
    
    all.addAll(getActiveIncomingConnections());
    
    return all;
  }
  
  /**
   *  Gets the active outgoing connections
   *
   *  @return list of connections
   */
  List getActiveOutgoingConnections()
  {
    return getActiveConnections(NodeConnection.CONNECTION_OUTGOING);  
  }    
  
  /**
   *  Gets the active incoming connections
   *
   *  @return active list
   */
  List getActiveIncomingConnections()
  {
    return getActiveConnections(NodeConnection.CONNECTION_INCOMING);  
  }    
  
  /**
   *  Gets the active outgoing connections
   *
   *  @return list of connections
   */
  private List getActiveConnections(int type)
  {
    LinkedList activeList = new LinkedList();
    
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while ( i.hasNext() )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == type &&
               connection.getStatus() == NodeConnection.STATUS_OK)
          {    
            activeList.add(connection);
          }
        }    
     }    
     
     return activeList;
  }    
  
  /**
   *  Gets a count of the active (running outgoing connections)
   *
   *  @return count
   */
  int getActiveOutgoingConnectionCount()
  {
    return getActiveConnectionCount(NodeConnection.CONNECTION_OUTGOING);  
  }  
  
 /**
  *  Get the count of active incoming connections
  *
  *  @return count
  */
  int getActiveIncomingConnectionCount()
  {
    return getActiveConnectionCount(NodeConnection.CONNECTION_INCOMING);
  }    
  
  /**
   *  Gets a count of the active (running outgoing connections)
   *
   *  @return count
   */
  int getActiveConnectionCount(int type)
  {
    int activeCount = 0;
    
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while ( i.hasNext() )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == type &&
               connection.getStatus() == NodeConnection.STATUS_OK)
          {    
            activeCount++;
          }
        }    
     }    
     
     return activeCount;
  }    

  
  /**
   *  Reduce the number of outgoing connections
   *
   */
  void reduceActiveOutgoingConnections(int newCount)
  {
    int activeCount = getActiveOutgoingConnectionCount();
    
    if ( activeCount <= newCount )  
    {    
      // nothing to do
      return;  
    }    
    
    int killCount = activeCount - newCount;
    int killed = 0;
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while ( i.hasNext() && killed != killCount )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == NodeConnection.CONNECTION_OUTGOING &&
               connection.getStatus() == NodeConnection.STATUS_OK)
          {    
            connection.shutdown();
            killed++;
          }
        }    
     }    
  }    
  
  /**
   *  Reduce the number of incoming connections
   *
   */
  void reduceActiveIncomingConnections(int newCount)
  {
    int activeCount = getActiveIncomingConnectionCount();
    
    if ( activeCount <= newCount )  
    {    
      // nothing to do
      return;  
    }    
    
    int killCount = activeCount - newCount;
    int killed = 0;
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while ( i.hasNext() && killed != killCount )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == NodeConnection.CONNECTION_INCOMING &&
               connection.getStatus() == NodeConnection.STATUS_OK)
          {    
            connection.shutdown();
            killed++;
          }
        }    
     }    
  }    

  /**
   *  Remove any dead connections from the list
   *
   *  @param type of collection to clean
   *  @return number of live connections remaining
   */
  int cleanDeadConnections(int type)
  {
    int liveCount = 0;
    Log.getLog().logInformation("Live connection list start: ");
    
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while (i.hasNext() )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == type )
          {    
            if ( connection.getStatus() != NodeConnection.STATUS_FAILED &&
                 connection.getStatus() != NodeConnection.STATUS_STOPPED )
            {    
              liveCount++;  
              Log.getLog().logInformation("Live connection: " +
                                          connection.getHost());
            }    
            else
            {    
              i.remove();  
            }    
          }
        }    
     }    
    
     Log.getLog().logInformation("Live connection list end");
     return liveCount;
  }
  
  /**
   *  Shuts down non-running connections
   *
   */
  void stopOutgoingConnectionAttempts()
  {
    synchronized ( currentConnectionList )  
    {
        Iterator i = currentConnectionList.iterator();
        
        while (i.hasNext() )
        {    
          NodeConnection connection = (NodeConnection)i.next();
          
          if ( connection.getType() == NodeConnection.CONNECTION_OUTGOING )
          {    
            if ( connection.getStatus() == NodeConnection.STATUS_CONNECTING )
            {    
              connection.shutdown();
              i.remove();
            }    
          }
        }    
     }    
  }    
  
  /**
   *  Closes all connections and removes them from the collection
   *
   */
  void empty()
  {
     synchronized ( currentConnectionList )  
    {
      Iterator i = currentConnectionList.iterator();
        
      while (i.hasNext() )
      {    
        NodeConnection connection = (NodeConnection)i.next();
          
        connection.shutdown();
        i.remove();  
      }
    }    
  }    
}