Changeset 830

Show
Ignore:
Timestamp:
09/05/06 23:17:07 (2 years ago)
Author:
alban
Message:

[Bug 136] first MultiTracker? implementation

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/source/org/kolaka/freecast/NodeConfigurator.java

    r405 r830  
    3131import java.text.ParseException; 
    3232import java.util.Iterator; 
     33import java.util.NoSuchElementException; 
    3334import java.util.Set; 
    3435import java.util.TreeSet; 
    …… 
    6566import org.kolaka.freecast.resource.ResourceLocator; 
    6667import org.kolaka.freecast.resource.ResourceLocators; 
     68import org.kolaka.freecast.tracker.NetworkIdentifier; 
    6769import org.kolaka.freecast.transport.MinaPeerReceivingConnectionFactory; 
    6870import org.kolaka.freecast.transport.MinaPeerSendingConnectionFactory; 
    …… 
    107109        public void configure(ConfigurableNode node, Configuration configuration) 
    108110                        throws ConfigurationException, IOException { 
    109                 Configuration trackerAddressConfiguration = configuration 
    110                                .subset("peerprovider.trackeraddress"); 
     111    Configuration peerProviderConfiguration = configuration.subset("peerprovider"); 
     112                Configuration trackerAddressConfiguration = peerProviderConfiguration.subset("trackeraddress"); 
    111113                InetSocketAddress trackerAddress = new InetSocketAddress( 
    112114                                trackerAddressConfiguration.getString("host"), 
    …… 
    116118                                "install a NodeService connected to the tracker " 
    117119                                                + trackerAddress); 
    118                 node.setNodeService(new DefaultNodeService(trackerAddress)); 
     120                DefaultNodeService nodeService = new DefaultNodeService(trackerAddress); 
     121     
     122    try { 
     123      nodeService.setNetworkId(NetworkIdentifier.getInstance(peerProviderConfiguration.getString("networkid"))); 
     124    } catch (NoSuchElementException e) { 
     125      LogFactory.getLog(getClass()).trace("no network identifier in configuration", e); 
     126    } 
     127     
     128    node.setNodeService(nodeService); 
    119129 
    120130                ConfigurablePeerControler peerControler = new DefaultPeerControler(); 

  • trunk/source/org/kolaka/freecast/manager/gui/MainFrame.java

    r691 r830  
    5656import org.kolaka.freecast.swing.ResourcesException; 
    5757import org.kolaka.freecast.tracker.Tracker; 
     58import org.kolaka.freecast.tracker.TrackerService; 
    5859import org.kolaka.freecast.transport.receiver.Receiver; 
    5960import org.kolaka.freecast.transport.receiver.Receiver.Source; 
    …… 
    6869        private static final long serialVersionUID = -5807144656289901506L; 
    6970 
    70         private final Tracker tracker; 
     71        private final TrackerService tracker; 
    7172 
    7273        private final Node node; 
    …… 
    7879        private final Action setupAction; 
    7980 
    80         public MainFrame(Resources resources, Tracker tracker, ConfigurableNode node, 
     81        public MainFrame(Resources resources, TrackerService tracker, ConfigurableNode node, 
    8182                        InetSocketAddress publicHttpServer) throws ResourcesException { 
    8283                super(resources); 
    …… 
    176177                private static final long serialVersionUID = 7865840587031612121L; 
    177178 
    178                 public TrackerControlPanel(Tracker tracker) { 
     179                public TrackerControlPanel(TrackerService tracker) { 
    179180                        super("Tracker"); 
    180181 

  • trunk/source/org/kolaka/freecast/node/DefaultNodeService.java

    r405 r830  
    3232import org.kolaka.freecast.service.ControlException; 
    3333import org.kolaka.freecast.service.LoopService; 
     34import org.kolaka.freecast.tracker.HttpMultiTrackerLocator; 
    3435import org.kolaka.freecast.tracker.HttpTrackerLocator; 
     36import org.kolaka.freecast.tracker.NetworkIdentifier; 
    3537import org.kolaka.freecast.tracker.Tracker; 
    3638import org.kolaka.freecast.tracker.TrackerException; 
    …… 
    4446public class DefaultNodeService extends LoopService implements NodeService { 
    4547 
    46        private ConfigurableNode node; 
     48  private ConfigurableNode node; 
    4749 
    48         private InetSocketAddress trackerAddress; 
     50  private InetSocketAddress trackerAddress; 
     51  private NetworkIdentifier networkId; 
    4952 
    50        /** 
    51         *  
    52         */ 
    53 protected Loop createLoop() { 
    54                return new Loop() { 
    55                        private int loopCount = 0; 
     53  /** 
     54  *  
     55  */ 
     56  protected Loop createLoop() { 
     57    return new Loop() { 
     58      private int loopCount = 0; 
    5659 
    57                        public long loop() throws LoopInterruptedException { 
    58                                node.checkQoS(); 
    59                                loopCount++; 
     60      public long loop() throws LoopInterruptedException { 
     61        node.checkQoS(); 
     62        loopCount++; 
    6063 
    61                                 if (loopCount % 2 == 0) { 
    62                                         NodeStatus status = node.getNodeStatus(); 
    63                                         LogFactory.getLog(getClass()).debug( 
    64                                                         "refresh node status " + status); 
     64        if (loopCount % 2 == 0) { 
     65          NodeStatus status = node.getNodeStatus(); 
     66          LogFactory.getLog(getClass()).debug("refresh node status " + status); 
    6567 
    66                                         try { 
    67                                                 try { 
    68                                                         tracker.refresh(status); 
    69                                                 } catch (TrackerException.UnknownNode e) { 
    70                                                         LogFactory.getLog(getClass()).debug( 
    71                                                                         "the tracker forgot our existence, register again"); 
    72                                                         registerNode(); 
    73                                                 }  
    74                                         } catch (Throwable t) { 
    75                                                 LogFactory.getLog(getClass()).error( 
    76                                                                 "failed to refresh status", t); 
    77                                         } 
    78                                 } 
     68          try { 
     69            try { 
     70              tracker.refresh(status); 
     71            } catch (TrackerException.UnknownNode e) { 
     72              LogFactory.getLog(getClass()).debug( 
     73                  "the tracker forgot our existence, register again"); 
     74              registerNode(); 
     75            } 
     76          } catch (Throwable t) { 
     77            LogFactory.getLog(getClass()).error("failed to refresh status", t); 
     78          } 
     79        } 
    7980 
    80                                 return 30 * 1000; 
    81                         } 
    82                 }; 
    83         } 
    84         private TrackerLocator trackerLocator = HttpTrackerLocator.getInstance(); 
     81        return 30 * 1000; 
     82      } 
     83    }; 
     84  } 
    8585 
    86        private Tracker tracker; 
     86  private Tracker tracker; 
    8787 
    88         /** 
    89          *  
    90          */ 
    91         public void init() throws ControlException { 
    92                 try { 
    93                         tracker = trackerLocator.resolve(trackerAddress); 
    94                 } catch (TrackerException e) { 
    95                         throw new ControlException("Can't connect to the tracker " 
    96                                         + trackerAddress, e); 
    97                 } 
     88  /** 
     89   *  
     90   */ 
     91  public void init() throws ControlException { 
     92    TrackerLocator trackerLocator; 
     93     
     94    if (networkId == null) { 
     95      trackerLocator = new HttpTrackerLocator(trackerAddress); 
     96    } else { 
     97      trackerLocator = new HttpMultiTrackerLocator(trackerAddress, networkId); 
     98    } 
     99     
     100    LogFactory.getLog(getClass()).debug("connect tracker " + trackerAddress + " (" + networkId + ")"); 
     101     
     102    try { 
     103      tracker = trackerLocator.resolve(); 
     104    } catch (TrackerException e) { 
     105      throw new ControlException("Can't connect to the tracker " 
     106          + trackerAddress, e); 
     107    } 
    98108 
    99                super.init(); 
    100        } 
     109    super.init(); 
     110  } 
    101111 
    102        /** 
    103         * @param node 
    104         *            The node to set. 
    105         */ 
    106        public void setNode(ConfigurableNode node) { 
    107                this.node = node; 
    108        } 
     112  /** 
     113  * @param node 
     114   *          The node to set. 
     115  */ 
     116  public void setNode(ConfigurableNode node) { 
     117    this.node = node; 
     118  } 
    109119 
    110         /** 
    111          * @param trackerAddress 
    112          *            The trackerAddress to set. 
    113          */ 
    114         public void setTrackerAddress(InetSocketAddress trackerAddress) { 
    115                 this.trackerAddress = trackerAddress; 
    116         } 
     120  /** 
     121   * @param trackerAddress 
     122   *          The trackerAddress to set. 
     123   */ 
     124  public void setTrackerAddress(InetSocketAddress trackerAddress) { 
     125    this.trackerAddress = trackerAddress; 
     126  } 
     127   
     128  public void setNetworkId(NetworkIdentifier networkId) { 
     129    this.networkId = networkId; 
     130  } 
    117131 
    118        /** 
    119         *  
    120         */ 
     132  /** 
     133  *  
     134  */ 
    121135 
    122        public void start() throws ControlException { 
    123                try { 
    124                        registerNode(); 
    125                } catch (TrackerException e) { 
    126                        throw new ControlException("Can't connect to the tracker " 
    127                                        + trackerAddress, e); 
    128                } 
     136  public void start() throws ControlException { 
     137    try { 
     138      registerNode(); 
     139    } catch (TrackerException e) { 
     140      throw new ControlException("Can't connect to the tracker " 
     141          + trackerAddress, e); 
     142    } 
    129143 
    130                 // TODO move the PeerProvider setting (to allow 
    131                 // MinimumOrderPeerProvider) 
    132                 LogFactory.getLog(getClass()).debug( 
    133                                 "change the peer provider to use tracker"); 
    134                 node.getConfigurablePeerControler().setPeerProvider( 
    135                                 createPeerProvider()); 
     144    // TODO move the PeerProvider setting (to allow 
     145    // MinimumOrderPeerProvider) 
     146    LogFactory.getLog(getClass()).debug( 
     147        "change the peer provider to use tracker"); 
     148    node.getConfigurablePeerControler().setPeerProvider(createPeerProvider()); 
    136149 
    137                super.start(); 
    138        } 
     150    super.start(); 
     151  } 
    139152 
    140        /** 
    141         * @throws TrackerException 
    142         */ 
    143        private void registerNode() throws TrackerException { 
    144                NodeIdentifier identifier = tracker.register(node.getPeerReference()); 
    145                 LogFactory.getLog(getClass()).info( 
    146                                "received node identifier " + identifier); 
    147                node.setIdentifier(identifier); 
    148        } 
     153  /** 
     154  * @throws TrackerException 
     155  */ 
     156  private void registerNode() throws TrackerException { 
     157    NodeIdentifier identifier = tracker.register(node.getPeerReference()); 
     158    LogFactory.getLog(getClass()) 
     159        .info("received node identifier " + identifier); 
     160    node.setIdentifier(identifier); 
     161  } 
    149162 
    150        protected PeerProvider createPeerProvider() { 
    151                return new PeerProvider() { 
    152                        public Set getPeerReferences() throws PeerProviderException { 
    153                                try { 
    154                                        return tracker.getPeerReferences(node.getIdentifier()); 
    155                                } catch (TrackerException e) { 
    156                                        String msg = "Can't retrieve new peer references from the tracker"; 
    157                                        throw new PeerProviderException(msg, e); 
    158                                } 
    159                        } 
    160                }; 
    161        } 
     163  protected PeerProvider createPeerProvider() { 
     164    return new PeerProvider() { 
     165      public Set getPeerReferences() throws PeerProviderException { 
     166        try { 
     167          return tracker.getPeerReferences(node.getIdentifier()); 
     168        } catch (TrackerException e) { 
     169          String msg = "Can't retrieve new peer references from the tracker"; 
     170          throw new PeerProviderException(msg, e); 
     171        } 
     172      } 
     173    }; 
     174  } 
    162175 
    163        /** 
    164         * @param trackerAddress 
    165         */ 
    166        public DefaultNodeService(InetSocketAddress trackerAddress) { 
    167                this.trackerAddress = trackerAddress; 
    168        } 
     176  /** 
     177  * @param trackerAddress 
     178  */ 
     179  public DefaultNodeService(InetSocketAddress trackerAddress) { 
     180    this.trackerAddress = trackerAddress; 
     181  } 
    169182 
    170        public void stop() throws ControlException { 
    171                super.stop(); 
     183  public void stop() throws ControlException { 
     184    super.stop(); 
    172185 
    173                LogFactory.getLog(getClass()).info("unregister node"); 
     186    LogFactory.getLog(getClass()).info("unregister node"); 
    174187 
    175                if (tracker != null) { 
    176                        try { 
    177                                tracker.unregister(node.getIdentifier()); 
    178                        } catch (TrackerException e) { 
    179                                throw new ControlException("Can't unregister the node", e); 
    180                        } 
    181                } 
    182        } 
     188    if (tracker != null) { 
     189      try { 
     190        tracker.unregister(node.getIdentifier()); 
     191      } catch (TrackerException e) { 
     192        throw new ControlException("Can't unregister the node", e); 
     193      } 
     194    } 
     195  } 
    183196} 

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

    r405 r830  
    2525 
    2626import java.net.InetSocketAddress; 
    27 import java.util.Set; 
    2827 
    29 import org.kolaka.freecast.node.NodeIdentifier; 
    30 import org.kolaka.freecast.node.NodeStatus; 
    31 import org.kolaka.freecast.peer.PeerReference; 
     28import org.apache.commons.logging.LogFactory; 
    3229import org.kolaka.freecast.service.ControlException; 
    3330import org.kolaka.freecast.transport.cas.ConnectionAssistantServer; 
    …… 
    3633import org.mortbay.jetty.servlet.ServletHttpContext; 
    3734 
    38 import com.caucho.hessian.server.HessianServlet; 
    39 import com.caucho.services.server.ServiceContext; 
    40  
    4135/** 
    4236 * @author <a href="mailto:alban.peignier@free.fr">Alban Peignier </a> 
    4337 */ 
    44 public class HttpTracker extends HessianServlet implements Tracker { 
    45         private static final long serialVersionUID = 3546076977887720249L; 
    46  
    47         private final Tracker tracker; 
    48  
     38public class HttpTracker implements TrackerService { 
     39   
    4940        private InetSocketAddress listenAddress; 
    5041 
    5142        private Server server; 
    52          
    5343        private ConnectionAssistantServer caServer; 
    5444         
    …… 
    6454                this.listenAddress = listenAddress; 
    6555        } 
     56   
     57  public Class connectorClass; 
     58   
     59  public void setConnectorClass(Class connectorClass) { 
     60    this.connectorClass = connectorClass; 
     61  } 
    6662 
    6763        public void start() throws ControlException { 
    68                 server = new Server(); 
     64    LogFactory.getLog(Main.class).info( 
     65        "start a HttpConnector on port " + listenAddress); 
     66    LogFactory.getLog(Main.class).trace( 
     67        "use connector " + connectorClass.getName()); 
     68 
     69    server = new Server(); 
    6970                SocketListener listener = new SocketListener(); 
    7071                listener.setInetAddress(listenAddress.getAddress()); 
    …… 
    7677 
    7778                try { 
    78                         context.addServlet("Tracker", "/tracker", HttpTracker.class 
    79                                         .getName()); 
     79                        context.addServlet("Tracker", "/tracker", connectorClass.getName()); 
    8080                } catch (Exception e) { 
    8181                        throw new ControlException("Can't install the tracker servlet", e); 
    …… 
    105105        } 
    106106 
    107         public HttpTracker() { 
    108                 DefaultTracker.ClientInfoProvider clientInfoProvider = new DefaultTracker.ClientInfoProvider() { 
    109                         public String getClientHost() throws TrackerException { 
    110                                 return ServiceContext.getRequest().getRemoteHost(); 
    111                         } 
    112                 }; 
    113                 tracker = new DefaultTracker(clientInfoProvider); 
    114         } 
    115  
    116         public Set getPeerReferences(NodeIdentifier identifier) 
    117                         throws TrackerException { 
    118                 return tracker.getPeerReferences(identifier); 
    119         } 
    120  
    121         public NodeIdentifier register(PeerReference reference) 
    122                         throws TrackerException { 
    123                 return tracker.register(reference); 
    124         } 
    125  
    126         public void unregister(NodeIdentifier identifier) throws TrackerException { 
    127                 tracker.unregister(identifier); 
    128         } 
    129  
    130         public void refresh(NodeStatus status) throws TrackerException { 
    131                 tracker.refresh(status); 
    132         } 
    133  
    134107} 

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

    r405 r830  
    3737 
    3838        public void configure(HttpTracker tracker, Configuration configuration) { 
     39    /* 
     40     * for the moment, the tracker.class changes the Connector implementation  
     41     * which creates its own Tracker instance 
     42     */  
     43    String trackerClass = configuration.getString("class", "single"); 
     44    Class connectorClass = HttpSimpleTrackerConnector.class;  
     45    if (trackerClass.equals("multi")) { 
     46      connectorClass = HttpMultiTrackerConnector.class; 
     47    } 
     48    tracker.setConnectorClass(connectorClass); 
     49     
    3950                Configuration listenAddressConfiguration = configuration 
    4051                                .subset("connector.listenaddress"); 

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

    r405 r830  
    2727import java.net.MalformedURLException; 
    2828 
     29import org.apache.commons.lang.Validate; 
     30 
    2931import com.caucho.hessian.client.HessianProxyFactory; 
    3032 
    …… 
    3638public class HttpTrackerLocator implements TrackerLocator { 
    3739 
    38         private static final TrackerLocator instance = new HttpTrackerLocator(); 
     40        private InetSocketAddress trackerAddress; 
    3941 
    40         public static TrackerLocator getInstance() { 
    41                 return instance; 
    42         } 
     42  public HttpTrackerLocator(InetSocketAddress trackerAddress) { 
     43    Validate.notNull(trackerAddress); 
     44    this.trackerAddress = trackerAddress; 
     45  } 
    4346 
    44         public Tracker resolve(InetSocketAddress address) throws TrackerException { 
    45                 String url = "http://" + address.getHostName() + ":" 
    46                                 + address.getPort() + "/tracker"; 
     47        public Tracker resolve() throws TrackerException { 
     48                String url = "http://" + trackerAddress.getHostName() + ":" 
     49                                + trackerAddress.getPort() + "/tracker"; 
    4750 
    4851                try { 

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

    r405 r830  
    2525 
    2626import org.apache.commons.configuration.Configuration; 
    27 import org.apache.commons.logging.LogFactory; 
    2827import org.kolaka.freecast.Application; 
    2928 
    …… 
    3231 */ 
    3332public class Main extends Application { 
    34         private HttpTracker tracker; 
     33         
     34  private TrackerService tracker; 
    3535 
    3636        public Main() { 
    …… 
    4646                new HttpTrackerConfigurator().configure(tracker, configuration 
    4747                                .subset("tracker")); 
    48                this.tracker = tracker; 
     48    this.tracker = tracker; 
    4949        } 
    5050 
    5151        protected void run() throws Exception { 
    52                 LogFactory.getLog(Main.class).info( 
    53                                 "start a HttpTracker on port " + tracker.getListenAddress()); 
    5452                tracker.start(); 
    5553 

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

    r405 r830  
    3030import org.kolaka.freecast.node.NodeStatus; 
    3131import org.kolaka.freecast.peer.PeerReference; 
    32 import org.kolaka.freecast.service.ControlException; 
    3332 
    3433/** 
    …… 
    4342        public ProtectedTracker(final Tracker tracker) { 
    4443                this.tracker = tracker; 
    45         } 
    46  
    47         public void start() throws ControlException { 
    48                 tracker.start(); 
    49         } 
    50  
    51         public void stop() throws ControlException { 
    52                 tracker.stop(); 
    5344        } 
    5445 

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

    r405 r830  
    2929import org.kolaka.freecast.node.NodeStatus; 
    3030import org.kolaka.freecast.peer.PeerReference; 
    31 import org.kolaka.freecast.service.Startable; 
    3231 
    3332/** 
    …… 
    3635 * @author <a href="mailto:alban.peignier@free.fr">Alban Peignier </a> 
    3736 */ 
    38 public interface Tracker extends Startable { 
     37public interface Tracker { 
    3938 
    4039        public NodeIdentifier register(PeerReference reference) 

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

    r405 r830  
    2424package org.kolaka.freecast.tracker; 
    2525 
    26 import java.net.InetSocketAddress; 
    2726 
    2827/** 
    …… 
    3332public interface TrackerLocator { 
    3433 
    35         public Tracker resolve(InetSocketAddress address) throws TrackerException; 
     34        public Tracker resolve() throws TrackerException; 
    3635 
    3736} 

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

    r405 r830  
    4848                tracker.start(); 
    4949 
    50                 Tracker remoteTracker = HttpTrackerLocator.getInstance().resolve( 
    51                                 address); 
     50                Tracker remoteTracker = new HttpTrackerLocator(address).resolve(); 
    5251                remoteTracker.register(InetPeerReference 
    5352                                .getInstance(new InetSocketAddress(4000)));