public void addListener(PluginListener l) {
    listeners.add(l);

    if (initialiser.isInitialisationComplete()) {

      fireInitComplete(l);
    }
  }
  public void addListener(long min_delta_bytes, final LongTermStatsListener listener) {
    listeners.add(new Object[] {listener, min_delta_bytes, session_total});

    dispatcher.dispatch(
        new AERunnable() {
          public void runSupport() {
            listener.updated(LongTermStatsImpl.this);
          }
        });
  }
Beispiel #3
0
  public void addListener(DeviceListener listener) {
    synchronized (this) {
      if (device_listeners == null) {

        device_listeners = new CopyOnWriteList<DeviceListener>();
      }

      device_listeners.add(listener);
    }
  }
  public SpeedManagerPingMapper createTransientPingMapper() {
    SpeedManagerPingMapper res =
        new SpeedManagerPingMapperImpl(this, "Transient", LONG_PERIOD_TICKS, true, true);

    transient_mappers.add(res);

    if (transient_mappers.size() > 32) {

      Debug.out("Transient mappers are growing too large");
    }

    return (res);
  }
  public void addListener(TableStructureModificationListener listener) {
    try {
      listeners_mon.enter();

      if (!listeners.contains(listener)) {
        listeners.add(listener);
      }

    } finally {

      listeners_mon.exit();
    }
  }
 public void addListener(DiskManagerListener listener) {
   listeners.add(listener);
 }
 public void addListener(SpeedManagerListener l) {
   listeners.add(l);
 }
Beispiel #8
0
 public void addListener(TranscodeTargetListener listener) {
   if (!listeners.contains(listener)) {
     listeners.add(listener);
   }
 }
Beispiel #9
0
 public static void addListener(TRTrackerUtilsListener l) {
   listeners.add(l);
 }
 public void addListener(ContentNetworkListener listener) {
   listeners.add(listener);
 }
  protected void split() throws TRTrackerAnnouncerException {

    String[] networks = f_provider == null ? null : f_provider.getNetworks();

    TRTrackerAnnouncerHelper to_activate = null;

    synchronized (this) {
      if (stopped || destroyed) {

        return;
      }

      TOTorrent torrent = getTorrent();

      TOTorrentAnnounceURLSet[] sets = torrent.getAnnounceURLGroup().getAnnounceURLSets();

      // sanitise dht entries

      if (sets.length == 0) {

        sets =
            new TOTorrentAnnounceURLSet[] {
              torrent
                  .getAnnounceURLGroup()
                  .createAnnounceURLSet(new URL[] {torrent.getAnnounceURL()})
            };

      } else {

        boolean found_decentralised = false;
        boolean modified = false;

        for (int i = 0; i < sets.length; i++) {

          TOTorrentAnnounceURLSet set = sets[i];

          URL[] urls = set.getAnnounceURLs().clone();

          for (int j = 0; j < urls.length; j++) {

            URL u = urls[j];

            if (u != null && TorrentUtils.isDecentralised(u)) {

              if (found_decentralised) {

                modified = true;

                urls[j] = null;

              } else {

                found_decentralised = true;
              }
            }
          }
        }

        if (modified) {

          List<TOTorrentAnnounceURLSet> s_list = new ArrayList<TOTorrentAnnounceURLSet>();

          for (TOTorrentAnnounceURLSet set : sets) {

            URL[] urls = set.getAnnounceURLs();

            List<URL> u_list = new ArrayList<URL>(urls.length);

            for (URL u : urls) {

              if (u != null) {

                u_list.add(u);
              }
            }

            if (u_list.size() > 0) {

              s_list.add(
                  torrent
                      .getAnnounceURLGroup()
                      .createAnnounceURLSet(u_list.toArray(new URL[u_list.size()])));
            }
          }

          sets = s_list.toArray(new TOTorrentAnnounceURLSet[s_list.size()]);
        }
      }

      List<TOTorrentAnnounceURLSet[]> new_sets = new ArrayList<TOTorrentAnnounceURLSet[]>();

      if (is_manual || sets.length < 2) {

        new_sets.add(sets);

      } else {

        List<TOTorrentAnnounceURLSet> list =
            new ArrayList<TOTorrentAnnounceURLSet>(Arrays.asList(sets));

        // often we have http:/xxxx/ and udp:/xxxx/ as separate groups - keep these together

        while (list.size() > 0) {

          TOTorrentAnnounceURLSet set1 = list.remove(0);

          boolean done = false;

          URL[] urls1 = set1.getAnnounceURLs();

          if (urls1.length == 1) {

            URL url1 = urls1[0];

            String prot1 = url1.getProtocol().toLowerCase();
            String host1 = url1.getHost();

            for (int i = 0; i < list.size(); i++) {

              TOTorrentAnnounceURLSet set2 = list.get(i);

              URL[] urls2 = set2.getAnnounceURLs();

              if (urls2.length == 1) {

                URL url2 = urls2[0];

                String prot2 = url2.getProtocol().toLowerCase();
                String host2 = url2.getHost();

                if (host1.equals(host2)) {

                  if ((prot1.equals("udp") && prot2.startsWith("http"))
                      || (prot2.equals("udp") && prot1.startsWith("http"))) {

                    list.remove(i);

                    new_sets.add(new TOTorrentAnnounceURLSet[] {set1, set2});

                    done = true;
                  }
                }
              }
            }
          }

          if (!done) {

            new_sets.add(new TOTorrentAnnounceURLSet[] {set1});
          }
        }
      }

      // work out the difference

      Iterator<TOTorrentAnnounceURLSet[]> ns_it = new_sets.iterator();

      // need to copy list as we modify it and returned list ain't thread safe

      List<TRTrackerAnnouncerHelper> existing_announcers =
          new ArrayList<TRTrackerAnnouncerHelper>(announcers.getList());

      List<TRTrackerAnnouncerHelper> new_announcers = new ArrayList<TRTrackerAnnouncerHelper>();

      // first look for unchanged sets

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] ns = ns_it.next();

        Iterator<TRTrackerAnnouncerHelper> a_it = existing_announcers.iterator();

        while (a_it.hasNext()) {

          TRTrackerAnnouncerHelper a = a_it.next();

          TOTorrentAnnounceURLSet[] os = a.getAnnounceSets();

          if (same(ns, os)) {

            ns_it.remove();
            a_it.remove();

            new_announcers.add(a);

            break;
          }
        }
      }

      // reuse existing announcers

      // first remove dht ones from the equation

      TRTrackerAnnouncerHelper existing_dht_announcer = null;
      TOTorrentAnnounceURLSet[] new_dht_set = null;

      ns_it = new_sets.iterator();

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] x = ns_it.next();

        if (TorrentUtils.isDecentralised(x[0].getAnnounceURLs()[0])) {

          new_dht_set = x;

          ns_it.remove();

          break;
        }
      }

      Iterator<TRTrackerAnnouncerHelper> an_it = existing_announcers.iterator();

      while (an_it.hasNext()) {

        TRTrackerAnnouncerHelper a = an_it.next();

        TOTorrentAnnounceURLSet[] x = a.getAnnounceSets();

        if (TorrentUtils.isDecentralised(x[0].getAnnounceURLs()[0])) {

          existing_dht_announcer = a;

          an_it.remove();

          break;
        }
      }

      if (existing_dht_announcer != null && new_dht_set != null) {

        new_announcers.add(existing_dht_announcer);

      } else if (existing_dht_announcer != null) {

        activated.remove(existing_dht_announcer);

        existing_dht_announcer.destroy();

      } else if (new_dht_set != null) {

        TRTrackerAnnouncerHelper a = create(torrent, networks, new_dht_set);

        new_announcers.add(a);
      }

      // now do the non-dht ones

      ns_it = new_sets.iterator();

      while (ns_it.hasNext() && existing_announcers.size() > 0) {

        TRTrackerAnnouncerHelper a = existing_announcers.remove(0);

        TOTorrentAnnounceURLSet[] s = ns_it.next();

        ns_it.remove();

        if (activated.contains(a)
            && torrent.getPrivate()
            && a instanceof TRTrackerBTAnnouncerImpl) {

          URL url = a.getTrackerURL();

          if (url != null) {

            forceStop((TRTrackerBTAnnouncerImpl) a, networks, url);
          }
        }

        a.setAnnounceSets(s, networks);

        new_announcers.add(a);
      }

      // create any new ones required

      ns_it = new_sets.iterator();

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] s = ns_it.next();

        TRTrackerAnnouncerHelper a = create(torrent, networks, s);

        new_announcers.add(a);
      }

      // finally fix up the announcer list to represent the new state

      Iterator<TRTrackerAnnouncerHelper> a_it = announcers.iterator();

      while (a_it.hasNext()) {

        TRTrackerAnnouncerHelper a = a_it.next();

        if (!new_announcers.contains(a)) {

          a_it.remove();

          try {
            if (activated.contains(a)
                && torrent.getPrivate()
                && a instanceof TRTrackerBTAnnouncerImpl) {

              URL url = a.getTrackerURL();

              if (url != null) {

                forceStop((TRTrackerBTAnnouncerImpl) a, networks, url);
              }
            }
          } finally {

            if (Logger.isEnabled()) {
              Logger.log(
                  new LogEvent(
                      getTorrent(), LOGID, "Deactivating " + getString(a.getAnnounceSets())));
            }

            activated.remove(a);

            a.destroy();
          }
        }
      }

      a_it = new_announcers.iterator();

      while (a_it.hasNext()) {

        TRTrackerAnnouncerHelper a = a_it.next();

        if (!announcers.contains(a)) {

          announcers.add(a);
        }
      }

      if (!is_manual && announcers.size() > 0) {

        if (activated.size() == 0) {

          TRTrackerAnnouncerHelper a = announcers.get(0);

          if (Logger.isEnabled()) {
            Logger.log(
                new LogEvent(getTorrent(), LOGID, "Activating " + getString(a.getAnnounceSets())));
          }

          activated.add(a);

          last_activation_time = SystemTime.getMonotonousTime();

          if (provider != null) {

            to_activate = a;
          }
        }

        setupActivationCheck(ACT_CHECK_INIT_DELAY);
      }
    }

    if (to_activate != null) {

      if (complete) {

        to_activate.complete(true);

      } else {

        to_activate.update(false);
      }
    }
  }
 public void addListener(DHTSpeedTesterContactListener listener) {
   listeners.add(listener);
 }
  protected void pingContacts(int tick_count) {
    List copy = null;

    synchronized (new_listeners) {
      if (new_listeners.size() > 0) {

        copy = new ArrayList(new_listeners);

        new_listeners.clear();
      }
    }

    if (copy != null) {

      for (int i = 0; i < copy.size(); i++) {

        DHTSpeedTesterListener listener = (DHTSpeedTesterListener) copy.get(i);

        listeners.add(listener);

        for (int j = 0; j < active_pings.size(); j++) {

          activePing ping = (activePing) active_pings.get(j);

          if (ping.isInformedAlive()) {

            try {

              listener.contactAdded(ping);

            } catch (Throwable e) {

              Debug.printStackTrace(e);
            }
          }
        }
      }
    }

    Iterator pit = active_pings.iterator();

    pingInstanceSet ping_set = new pingInstanceSet(true);

    while (pit.hasNext()) {

      activePing ping = (activePing) pit.next();

      if (ping.update(ping_set, tick_count)) {

        if (!ping.isInformedAlive()) {

          ping.setInformedAlive();

          Iterator it = listeners.iterator();

          while (it.hasNext()) {

            try {
              ((DHTSpeedTesterListener) it.next()).contactAdded(ping);

            } catch (Throwable e) {

              Debug.printStackTrace(e);
            }
          }
        }
      }

      if (ping.isDead()) {

        pit.remove();

        ping.informDead();
      }
    }

    ping_set.setFull();

    // we try and keep three active pings running so we can spot overall trends in ping time
    // each active ping is selected from the best rtt from the current 3 best three rtt estimates

    int num_active = active_pings.size();

    if (num_active < contact_num) {

      Set pc =
          new TreeSet(
              new Comparator() {
                public int compare(Object o1, Object o2) {
                  potentialPing p1 = (potentialPing) o1;
                  potentialPing p2 = (potentialPing) o2;

                  return (p1.getRTT() - p2.getRTT());
                }
              });

      synchronized (pending_contacts) {
        pc.addAll(pending_contacts);
      }

      Iterator it = pc.iterator();

      if (pc.size() >= 3) {

        // find best candidates

        List pps = new ArrayList();

        for (int i = 0; i < 3; i++) {

          potentialPing pp = (potentialPing) it.next();

          pps.add(pp);

          it.remove();

          synchronized (pending_contacts) {
            pending_contacts.remove(pp);
          }
        }

        active_pings.add(new activePing(pps));
      }
    } else if (num_active > contact_num) {

      for (int i = 0; i < num_active - contact_num; i++) {

        ((activePing) active_pings.get(i)).destroy();
      }
    }
  }
  public static TRTrackerServer create(
      String name,
      int protocol,
      int port,
      InetAddress bind_ip,
      boolean ssl,
      boolean apply_ip_filter,
      boolean main_tracker,
      boolean start_up_ready)
      throws TRTrackerServerException {
    try {
      class_mon.enter();

      TRTrackerServerImpl server;

      if (protocol == TRTrackerServerFactory.PR_TCP) {

        if (COConfigurationManager.getBooleanParameter("Tracker TCP NonBlocking")
            && main_tracker
            && !ssl) {

          server =
              new TRNonBlockingServer(
                  name,
                  port,
                  bind_ip,
                  apply_ip_filter,
                  start_up_ready,
                  new TRNonBlockingServerProcessorFactory() {
                    public TRNonBlockingServerProcessor create(
                        TRTrackerServerTCP _server, SocketChannel _socket) {
                      return (new NonBlockingProcessor(_server, _socket));
                    }
                  });
        } else {

          server = new TRBlockingServer(name, port, bind_ip, ssl, apply_ip_filter, start_up_ready);
        }

      } else if (protocol == TRTrackerServerFactory.PR_UDP) {

        if (ssl) {

          throw (new TRTrackerServerException("TRTrackerServerFactory: UDP doesn't support SSL"));
        }

        server = new TRTrackerServerUDP(name, port, start_up_ready);

      } else {

        server = new TRTrackerServerDHT(name, start_up_ready);
      }

      servers.add(server);

      for (int i = 0; i < listeners.size(); i++) {

        ((TRTrackerServerFactoryListener) listeners.get(i)).serverCreated(server);
      }

      return (server);

    } finally {

      class_mon.exit();
    }
  }