Changeset 832

Show
Ignore:
Timestamp:
09/06/06 08:37:59 (2 years ago)
Author:
alban
Message:

[Bug 136] add a purge task into DefaultMultiTracker?

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/source/org/kolaka/freecast/tracker/DefaultMultiTracker.java

    r830 r832  
    2525 
    2626import java.util.Date; 
     27import java.util.Iterator; 
    2728import java.util.Map; 
    2829import java.util.Set; 
    2930import java.util.TreeMap; 
    3031 
     32import org.apache.commons.lang.Validate; 
    3133import org.apache.commons.logging.LogFactory; 
    3234import org.kolaka.freecast.node.NodeIdentifier; 
    3335import org.kolaka.freecast.node.NodeStatus; 
    3436import org.kolaka.freecast.peer.PeerReference; 
     37import org.kolaka.freecast.timer.DefaultTimer; 
     38import org.kolaka.freecast.timer.Timer; 
     39import org.kolaka.freecast.timer.TimerUser; 
    3540import org.kolaka.freecast.tracker.DefaultTracker.ClientInfoProvider; 
    3641 
    37 public class DefaultMultiTracker { 
     42public class DefaultMultiTracker implements TimerUser { 
    3843 
    3944  private Map trackers = new TreeMap(); 
    …… 
    4348  public DefaultMultiTracker(final ClientInfoProvider clientInfoProvider) { 
    4449    this.clientInfoProvider = clientInfoProvider; 
    45   } 
    4650 
    47   private Tracker getTracker(NetworkIdentifier identifier) { 
     51    Runnable purgeRunnable = new Runnable() { 
     52      public void run() { 
     53        purge(); 
     54      } 
     55    }; 
     56    timer.executePeriodically(DefaultTimer.minutes(1), purgeRunnable , false); 
     57} 
     58 
     59  private synchronized Tracker getTracker(NetworkIdentifier identifier) { 
    4860    Tracker tracker = (Tracker) trackers.get(identifier); 
    4961    if (tracker == null) { 
    …… 
    5668   
    5769  protected Tracker createTracker(ClientInfoProvider clientInfoProvider) { 
    58     return new DefaultTracker(clientInfoProvider); 
     70    return new TimedTracker(new DefaultTracker(clientInfoProvider)); 
    5971  } 
    6072 
    …… 
    7890    return getTracker(network).getPeerReferences(node); 
    7991  } 
     92   
     93  private Timer timer = DefaultTimer.getInstance(); 
     94   
     95  public void setTimer(Timer timer) { 
     96    Validate.notNull(timer); 
     97    this.timer = timer; 
     98  } 
     99     
     100  private synchronized void purge() { 
     101    Date olderLastRequest = new Date(System.currentTimeMillis() - DefaultTimer.minutes(5)); 
     102    LogFactory.getLog(getClass()).debug("purge trackers unused since " + olderLastRequest); 
     103    for (Iterator iter = trackers.entrySet().iterator(); iter.hasNext();) { 
     104      Map.Entry entry = (Map.Entry) iter.next(); 
     105      NetworkIdentifier networkId = (NetworkIdentifier) entry.getKey(); 
     106      TimedTracker tracker = (TimedTracker) entry.getValue(); 
     107       
     108      if (tracker.getLastRequest().before(olderLastRequest)) { 
     109        LogFactory.getLog(getClass()).info("purge tracker " + networkId); 
     110        iter.remove(); 
     111      } 
     112    } 
     113    LogFactory.getLog(getClass()).debug(trackers.size() + " trackers kept"); 
     114  } 
     115   
     116  static class TimedTracker implements Tracker { 
     117     
     118    private final Tracker delegate; 
     119    private Date lastRequest = new Date(); 
     120     
     121    public TimedTracker(final Tracker delegate) { 
     122      Validate.notNull(delegate); 
     123      this.delegate = delegate; 
     124    } 
     125 
     126    public Date getLastRequest() { 
     127      return lastRequest; 
     128    } 
     129 
     130    public Set getPeerReferences(NodeIdentifier node) throws TrackerException { 
     131      updateLastRequest(); 
     132      return delegate.getPeerReferences(node); 
     133    } 
     134 
     135    public void refresh(NodeStatus status) throws TrackerException { 
     136      updateLastRequest(); 
     137      delegate.refresh(status); 
     138    } 
     139 
     140    public NodeIdentifier register(PeerReference reference) throws TrackerException { 
     141      updateLastRequest(); 
     142      return delegate.register(reference); 
     143    } 
     144 
     145    public void unregister(NodeIdentifier identifier) throws TrackerException { 
     146      updateLastRequest(); 
     147      delegate.unregister(identifier); 
     148    } 
     149 
     150    private void updateLastRequest() { 
     151      lastRequest = new Date(); 
     152    } 
     153     
     154  } 
    80155 
    81156} 

  • trunk/source/org/kolaka/freecast/tracker/DefaultTracker.java

    r405 r832  
    133133                if (entry != null) { 
    134134                        LogFactory.getLog(getClass()).debug("unregister " + entry); 
     135      auditor.unregister(entry.getReference()); 
    135136                } else { 
    136137                        String clientHost = "unknown"; 
    …… 
    145146                        LogFactory.getLog(getClass()).warn(msg); 
    146147                } 
    147                 auditor.unregister(entry.getReference()); 
     148                 
    148149                auditor.connectedNodes(entries.size()); 
    149150        } 

  • trunk/source/org/kolaka/freecast/tracker/MultiTrackerAdapter.java

    r830 r832  
    2727 
    2828import org.apache.commons.lang.Validate; 
     29import org.apache.commons.logging.LogFactory; 
    2930import org.kolaka.freecast.node.NodeIdentifier; 
    3031import org.kolaka.freecast.node.NodeStatus; 
    …… 
    3233 
    3334public class MultiTrackerAdapter implements Tracker { 
    34    
     35 
    3536  private NetworkIdentifier networkId; 
     37 
    3638  private MultiTracker tracker; 
    37    
     39 
    3840  public MultiTrackerAdapter(NetworkIdentifier networkId, MultiTracker tracker) { 
    3941    Validate.notNull(networkId); 
    4042    Validate.notNull(tracker); 
    41      
     43 
    4244    this.networkId = networkId; 
    4345    this.tracker = tracker; 
    4446  } 
     47   
     48  private void logInvocation(String description) { 
     49    LogFactory.getLog(getClass()).debug(description + " on network " + networkId); 
     50  } 
    4551 
    4652  public Set getPeerReferences(NodeIdentifier node) throws TrackerException { 
     53    logInvocation("getPeerStatus for " + node); 
    4754    return tracker.getPeerReferences(networkId, node); 
    4855  } 
    4956 
    5057  public void refresh(NodeStatus status) throws TrackerException { 
    51     tracker.refresh(networkId, status);  } 
     58    logInvocation("refresh " + status); 
     59    tracker.refresh(networkId, status); 
     60  } 
    5261 
    5362  public NodeIdentifier register(PeerReference reference) 
    5463      throws TrackerException { 
     64    logInvocation("register " + reference); 
    5565    return tracker.register(networkId, reference); 
    5666  } 
    5767 
    5868  public void unregister(NodeIdentifier identifier) throws TrackerException { 
     69    logInvocation("unregister " + identifier); 
    5970    tracker.unregister(this.networkId, identifier); 
    6071  } 

  • trunk/source/org/kolaka/freecast/tracker/test/TrackerServletTest.java

    r830 r832  
    2626import java.net.InetSocketAddress; 
    2727 
    28 import junit.framework.TestCase; 
    29  
     28import org.kolaka.freecast.node.NodeIdentifier; 
    3029import org.kolaka.freecast.peer.InetPeerReference; 
     30import org.kolaka.freecast.test.BaseTestCase; 
     31import org.kolaka.freecast.tracker.HttpMultiTrackerConnector; 
     32import org.kolaka.freecast.tracker.HttpMultiTrackerLocator; 
     33import org.kolaka.freecast.tracker.HttpSimpleTrackerConnector; 
    3134import org.kolaka.freecast.tracker.HttpTracker; 
    3235import org.kolaka.freecast.tracker.HttpTrackerLocator; 
     36import org.kolaka.freecast.tracker.NetworkIdentifier; 
    3337import org.kolaka.freecast.tracker.Tracker; 
     38import org.kolaka.freecast.tracker.TrackerException; 
     39import org.kolaka.freecast.tracker.TrackerLocator; 
    3440 
    3541/** 
    …… 
    3844 * @author <a href="mailto:alban.peignier@free.fr">Alban Peignier </a> 
    3945 */ 
    40 public class TrackerServletTest extends TestCase { 
     46public class TrackerServletTest extends BaseTestCase { 
    4147 
    42         public void testBindConnect() throws Exception { 
    43                 InetSocketAddress address = new InetSocketAddress(50000 + (int) (Math 
    44                                 .random() * 1000)); 
    45                 HttpTracker tracker = new HttpTracker(); 
     48        private InetSocketAddress address; 
    4649 
     50  protected void setUp() throws Exception { 
     51    super.setUp(); 
     52    address = new InetSocketAddress(50000 + (int) (Math 
     53        .random() * 1000)); 
     54  } 
     55   
     56  public void testSingle() throws Exception { 
     57    testBindConnect(HttpSimpleTrackerConnector.class, new HttpTrackerLocator(address)); 
     58  } 
     59 
     60  public void testMulti() throws Exception { 
     61    testBindConnect(HttpMultiTrackerConnector.class, new HttpMultiTrackerLocator(address, NetworkIdentifier.getRandomInstance())); 
     62  } 
     63 
     64  private void testBindConnect(Class connectorClass, TrackerLocator locator) throws Exception { 
     65    HttpTracker tracker = new HttpTracker(); 
     66 
     67    tracker.setConnectorClass(connectorClass); 
    4768                tracker.setListenAddress(address); 
     69     
    4870                tracker.start(); 
    49  
    50                 Tracker remoteTracker = new HttpTrackerLocator(address).resolve(); 
    51                 remoteTracker.register(InetPeerReference 
    52                                 .getInstance(new InetSocketAddress(4000))); 
    53  
    54                 tracker.stop(); 
     71     
     72    try { 
     73                Tracker remoteTracker = locator.resolve(); 
     74       
     75                InetPeerReference nodeReference = InetPeerReference.getInstance(new InetSocketAddress(4000)); 
     76      testRemoteTracker(remoteTracker, nodeReference); 
     77       
     78      testRemoteTracker(remoteTracker, null); 
     79    } finally { 
     80      tracker.stop(); 
     81    } 
    5582        } 
    5683 
     84  /** 
     85   * @param remoteTracker 
     86   * @param nodeReference 
     87   * @throws TrackerException 
     88   */ 
     89  private void testRemoteTracker(Tracker remoteTracker, InetPeerReference nodeReference) throws TrackerException { 
     90    NodeIdentifier nodeIdentifier = remoteTracker.register(nodeReference); 
     91    remoteTracker.getPeerReferences(nodeIdentifier); 
     92    remoteTracker.unregister(nodeIdentifier); 
     93  } 
     94   
     95 
    5796}